From 01a4628d841771da3860e937915dc23d59d6a572 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 22 Jan 2018 09:52:39 -0700 Subject: [PATCH 001/190] Distance-2 Coloring Driver Update Adding an 'average' summary printout for time, colors, phases into the driver application. --- perf_test/graph/KokkosGraph_color_d2.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 60240d6556..3575836af5 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -271,6 +271,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.set_verbose(true); } + // accumulators for average stats + double total_time = 0.0; + size_t total_colors = 0; + size_t total_phases = 0; + for (int i = 0; i < repeat; ++i) { @@ -297,7 +302,20 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; + total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); + total_colors += kh.get_graph_coloring_handle()->get_num_colors(); + total_phases += kh.get_graph_coloring_handle()->get_num_phases(); } + + double avg_time = total_time / repeat; + double avg_colors = total_colors / (double)repeat; + double avg_phases = total_phases / (double)repeat; + + std::cout << "Summary:" << std::endl + << " Avg Time : " << avg_time << std::endl + << " Avg colors: " << avg_colors << std::endl + << " Avg Phases: " << avg_phases << std::endl; + } From e1143e846ae89b5846b762de8f3531f24583a415 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 22 Jan 2018 19:11:55 -0700 Subject: [PATCH 002/190] Distance-2 color, add CSV style summary line into test output. --- perf_test/graph/KokkosGraph_color_d2.cpp | 43 +++++++++++++++++++----- 1 file changed, 34 insertions(+), 9 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 3575836af5..792fe0a225 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -42,16 +42,16 @@ */ #include +// STL #include #include #include - - #include // std::default_random_engine #include // std::shuffle #include -#include "KokkosKernels_config.h" +// Kokkos +#include "KokkosKernels_config.h" #include "KokkosGraph_Distance2Color.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_MyCRSMatrix.hpp" @@ -252,9 +252,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.dimension_0() == number of edges in the 'graph' - std::cout << "Num verts: " << crsGraph.numRows() << std::endl - << "Num edges: " << crsGraph.entries.dimension_0() << std::endl; - KernelHandle kh; kh.set_team_work_size(chunk_size); kh.set_shmem_size(shmemsize); @@ -275,6 +272,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) double total_time = 0.0; size_t total_colors = 0; size_t total_phases = 0; + + std::string label_algorithm; for (int i = 0; i < repeat; ++i) { @@ -284,12 +283,15 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) case 1: // kh.create_graph_coloring_handle(COLORING_SPGEMM); kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; break; case 2: kh.create_graph_coloring_handle(COLORING_D2); + label_algorithm = "COLORING_D2"; break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; break; } @@ -311,10 +313,33 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) double avg_colors = total_colors / (double)repeat; double avg_phases = total_phases / (double)repeat; + std::string a_mtx_bin_file = params.a_mtx_bin_file; + a_mtx_bin_file = a_mtx_bin_file.substr( a_mtx_bin_file.find_last_of("/\\")+1 ); + std::cout << "Summary:" << std::endl - << " Avg Time : " << avg_time << std::endl - << " Avg colors: " << avg_colors << std::endl - << " Avg Phases: " << avg_phases << std::endl; + << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl + << " Filename : " << a_mtx_bin_file << std::endl + << " Num Verts : " << crsGraph.numRows() << std::endl + << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl + << " Concurrency: " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl + << " Algorithm : " << label_algorithm << std::endl + << " Avg Time : " << avg_time << std::endl + << " Avg colors : " << avg_colors << std::endl + << " Avg Phases : " << avg_phases << std::endl + << std::endl; + + std::cout << "CSV" + << "," << a_mtx_bin_file + << "," << crsGraph.numRows() + << "," << crsGraph.entries.dimension_0() + << "," << Kokkos::DefaultExecutionSpace::name() + << "," << Kokkos::DefaultExecutionSpace::concurrency() + << "," << label_algorithm + << "," << avg_time + << "," << avg_colors + << "," << avg_phases + << std::endl; + //Kokkos::print_configuration(std::cout); } From 1497f185984ad793b4a2a5ef1627f5119a6df229 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 23 Jan 2018 09:25:49 -0700 Subject: [PATCH 003/190] D2 Coloring app: style fix --- perf_test/graph/KokkosGraph_color_d2.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 792fe0a225..d008ed9f27 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -89,7 +89,7 @@ void print_options(std::ostream& os, const char* app_name, unsigned int indent=0 os << "Usage:" << std::endl << spaces << app_name << " [parameters]" << std::endl << std::endl - << spaces << "Parameters:" + << spaces << "Parameters:" << std::endl << spaces << " Parallelism (select one of the following):" << std::endl << spaces << " serial Execute serially." << std::endl << spaces << " threads Use N posix threads." << std::endl From ba8832112c57fedb29ab4383c7a940b3d8f3f5ed Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 23 Jan 2018 09:30:02 -0700 Subject: [PATCH 004/190] D2 Coloring app: style fix (2) --- perf_test/graph/KokkosGraph_color_d2.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index d008ed9f27..505dc9a2b1 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -87,7 +87,7 @@ void print_options(std::ostream& os, const char* app_name, unsigned int indent=0 { std::string spaces(indent, ' '); os << "Usage:" << std::endl - << spaces << app_name << " [parameters]" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl << std::endl << spaces << "Parameters:" << std::endl << spaces << " Parallelism (select one of the following):" << std::endl From d3f6034751be601b7fc8a37b4fd8a96441c37dfe Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 22 May 2018 10:29:36 -0600 Subject: [PATCH 005/190] fixing compileKokkosKernels.sh script --- example/buildlib/compileKokkosKernels.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/buildlib/compileKokkosKernels.sh b/example/buildlib/compileKokkosKernels.sh index 7102468311..9f5978bb58 100755 --- a/example/buildlib/compileKokkosKernels.sh +++ b/example/buildlib/compileKokkosKernels.sh @@ -6,7 +6,7 @@ KOKKOSKERNELS_OFFSETS=int,size_t #offset types to instantiate KOKKOSKERNELS_PATH=../.. #path to kokkos-kernels top directory. KOKKOSKERNELS_OPTIONS=eti-only #options for kokkoskernels CXXFLAGS="-Wall -pedantic -Werror -O3 -g -Wshadow -Wsign-compare -Wignored-qualifiers -Wempty-body -Wclobbered -Wuninitialized" -CXX=${KOKKOS_PATH}/config/nvcc_wrapper #icpc # +CXX=${KOKKOS_PATH}/bin/nvcc_wrapper #icpc # KOKKOS_DEVICES=Serial,Cuda,OpenMP #devices Cuda... KOKKOS_ARCHS=Pascal60,Power8 From 04e28fbc9aabe4970992f9b1f00eaa5868ad922c Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 23 May 2018 17:50:20 -0600 Subject: [PATCH 006/190] Initial stub for a new d2 test --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 135 ++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp new file mode 100644 index 0000000000..25bf0d2e3d --- /dev/null +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -0,0 +1,135 @@ +/* +//@HEADER +// ************************************************************************ +// +// Kokkos v. 2.0 +// Copyright (2014) Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions Contact H. Carter Edwards (hcedwar@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +// EXERCISE 1 Goal: +// Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. +#include + +#include +#include +#include +#include +#include + +#include + + +int main( int argc, char* argv[] ) +{ +#if 0 + int N = 100; + int M = 100; + int S = 100; + int nrepeat = 1; + // Read command line arguments. + for ( int i = 0; i < argc; i++ ) + { + if ( ( strcmp( argv[ i ], "-N" ) == 0 ) || ( strcmp( argv[ i ], "-Rows" ) == 0 ) ) + { + N = pow( 2, atoi( argv[ ++i ] ) ); + printf( " User N is %d\n", N ); + } + else if ( ( strcmp( argv[ i ], "-M" ) == 0 ) || ( strcmp( argv[ i ], "-Columns" ) == 0 ) ) + { + M = pow( 2, atof( argv[ ++i ] ) ); + printf( " User M is %d\n", M ); + } + else if ( ( strcmp( argv[ i ], "-S" ) == 0 ) || ( strcmp( argv[ i ], "-Size" ) == 0 ) ) + { + S = pow( 2, atof( argv[ ++i ] ) ); + printf( " User S is %d\n", S ); + } + else if ( strcmp( argv[ i ], "-nrepeat" ) == 0 ) + { + nrepeat = atoi( argv[ ++i ] ); + } + else if ( ( strcmp( argv[ i ], "-h" ) == 0 ) || ( strcmp( argv[ i ], "-help" ) == 0 ) ) + { + printf( " y^T*A*x Options:\n" ); + printf( " -Rows (-N) : exponent num, determines number of rows 2^num (default: 2^12 = 4096)\n" ); + printf( " -Columns (-M) : exponent num, determines number of columns 2^num (default: 2^10 = 1024)\n" ); + printf( " -Size (-S) : exponent num, determines total matrix size 2^num (default: 2^22 = 4096*1024 )\n" ); + printf( " -nrepeat : number of repetitions (default: 100)\n" ); + printf( " -help (-h): print this message\n\n" ); + exit( 1 ); + } + } +#endif + + Kokkos::initialize( argc, argv ); + + // Timer products. + struct timeval begin, end; + + gettimeofday( &begin, NULL ); + + std::cout << "Do stuff here!" << std::endl; + + gettimeofday( &end, NULL ); + + // Calculate time. + double time = 1.0 * ( end.tv_sec - begin.tv_sec ) + 1.0e-6 * ( end.tv_usec - begin.tv_usec ); + + std::cout << "Time: " << time << std::endl; + +#if 0 + // Calculate bandwidth. + // Each matrix A row (each of length M) is read once. + // The x vector (of length M) is read N times. + // The y vector (of length N) is read once. + // double Gbytes = 1.0e-9 * double( sizeof(double) * ( 2 * M * N + N ) ); + double Gbytes = 1.0e-9 * double( sizeof(double) * ( M + M * N + N ) ); + + // Print results (problem size, time and bandwidth in GB/s). + printf( " N( %d ) M( %d ) nrepeat ( %d ) problem( %g MB ) time( %g s ) bandwidth( %g GB/s )\n", + N, M, nrepeat, Gbytes * 1000, time, Gbytes * nrepeat / time ); + + delete[] A; + delete[] y; + delete[] x; +#endif + + Kokkos::finalize(); + return 0; +} + From 6a6e7913fbf2ccdecaaccef169bba7931d5753df Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 May 2018 17:24:48 -0600 Subject: [PATCH 007/190] Update d2 test driver --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 619 ++++++++++++++++-- 1 file changed, 565 insertions(+), 54 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 25bf0d2e3d..598c288974 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -45,91 +45,602 @@ // Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. #include -#include #include #include #include +#include +#include #include #include +#include +#include +#include +#include + + +using namespace KokkosGraph; +#ifdef KOKKOSKERNELS_INST_DOUBLE +typedef double kk_scalar_t; +#else +#ifdef KOKKOSKERNELS_INST_FLOAT +typedef float kk_scalar_t; +#endif +#endif + +#ifdef KOKKOSKERNELS_INST_OFFSET_INT +typedef int kk_size_type; +#else +#ifdef KOKKOSKERNELS_INST_OFFSET_SIZE_T +typedef size_t kk_size_type; +#endif +#endif + +#ifdef KOKKOSKERNELS_INST_ORDINAL_INT +typedef int kk_lno_t; +#else +#ifdef KOKKOSKERNELS_INST_ORDINAL_INT64_T +typedef int64_t kk_lno_t; +#endif +#endif + + +using namespace KokkosGraph; + + + +void print_options(std::ostream &os, const char *app_name, unsigned int indent = 0) +{ + std::string spaces(indent, ' '); + os << "Usage:" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl + << std::endl + << spaces << "Parameters:" << std::endl + << spaces << " Parallelism (select one of the following):" << std::endl + << spaces << " serial Execute serially." << std::endl + << spaces << " threads Use N posix threads." << std::endl + << spaces << " openmp Use OpenMP with N threads." << std::endl + << spaces << " cuda Use CUDA" << std::endl + << std::endl + << spaces << " Required Parameters:" << std::endl + << spaces << " amtx Input file in Matrix Market format (.mtx)." << std::endl + << std::endl + << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl + << spaces << " COLORING_D2_MATRIX_SQUARED - Distance-2 coloring using matrix-squared + Distance-1 coloring method." << std::endl + << spaces << " COLORING_D2 - Distance-2 coloring using traversal based method." << std::endl + << std::endl + << spaces << " Optional Parameters:" << std::endl + << spaces << " chunksize Set the chunk size." << std::endl + << spaces << " dynamic Use dynamic scheduling." << std::endl + << spaces << " repeat Set number of test repetitions (Default: 6) " << std::endl + << spaces << " teamsize Set the team size." << std::endl + << spaces << " vectorsize Set the vector size." << std::endl + << spaces << " verbose Enable verbose mode (print timing + extra information" << std::endl + << spaces << " help Print out command line help." << std::endl + << spaces << " " << std::endl; +} + -int main( int argc, char* argv[] ) +int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) { -#if 0 - int N = 100; - int M = 100; - int S = 100; - int nrepeat = 1; - // Read command line arguments. - for ( int i = 0; i < argc; i++ ) + bool got_required_param_amtx = false; + bool got_required_param_algorithm = false; + + for(int i = 1; i < argc; ++i) { - if ( ( strcmp( argv[ i ], "-N" ) == 0 ) || ( strcmp( argv[ i ], "-Rows" ) == 0 ) ) + if(0 == strcasecmp(argv[i], "threads")) + { + params.use_threads = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "serial")) + { + params.use_serial = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "openmp")) + { + params.use_openmp = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "cuda")) + { + params.use_cuda = 1; + } + else if(0 == strcasecmp(argv[i], "repeat")) + { + params.repeat = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "chunksize")) + { + params.chunk_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "teamsize")) + { + params.team_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "vectorsize")) + { + params.vector_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "amtx")) + { + got_required_param_amtx = true; + params.a_mtx_bin_file = argv[++i]; + } + else if(0 == strcasecmp(argv[i], "dynamic")) { - N = pow( 2, atoi( argv[ ++i ] ) ); - printf( " User N is %d\n", N ); + params.use_dynamic_scheduling = 1; } - else if ( ( strcmp( argv[ i ], "-M" ) == 0 ) || ( strcmp( argv[ i ], "-Columns" ) == 0 ) ) + else if(0 == strcasecmp(argv[i], "verbose")) { - M = pow( 2, atof( argv[ ++i ] ) ); - printf( " User M is %d\n", M ); + params.verbose = 1; } - else if ( ( strcmp( argv[ i ], "-S" ) == 0 ) || ( strcmp( argv[ i ], "-Size" ) == 0 ) ) + else if(0 == strcasecmp(argv[i], "algorithm")) { - S = pow( 2, atof( argv[ ++i ] ) ); - printf( " User S is %d\n", S ); + ++i; + if(0 == strcasecmp(argv[i], "COLORING_D2_MATRIX_SQUARED")) + { + params.algorithm = 1; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2")) + { + params.algorithm = 2; + got_required_param_algorithm = true; + } + else + { + std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; + print_options(std::cout, argv[0]); + return 1; + } } - else if ( strcmp( argv[ i ], "-nrepeat" ) == 0 ) + else if(0 == strcasecmp(argv[i], "help") || 0 == strcasecmp(argv[i], "-h")) { - nrepeat = atoi( argv[ ++i ] ); + print_options(std::cout, argv[0]); + return 1; } - else if ( ( strcmp( argv[ i ], "-h" ) == 0 ) || ( strcmp( argv[ i ], "-help" ) == 0 ) ) + else { - printf( " y^T*A*x Options:\n" ); - printf( " -Rows (-N) : exponent num, determines number of rows 2^num (default: 2^12 = 4096)\n" ); - printf( " -Columns (-M) : exponent num, determines number of columns 2^num (default: 2^10 = 1024)\n" ); - printf( " -Size (-S) : exponent num, determines total matrix size 2^num (default: 2^22 = 4096*1024 )\n" ); - printf( " -nrepeat : number of repetitions (default: 100)\n" ); - printf( " -help (-h): print this message\n\n" ); - exit( 1 ); + std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; + print_options(std::cout, argv[0]); + return 1; } } -#endif - Kokkos::initialize( argc, argv ); + if(!got_required_param_amtx) + { + std::cout << "Missing required parameter amtx" << std::endl << std::endl; + print_options(std::cout, argv[0]); + return 1; + } + if(!got_required_param_algorithm) + { + std::cout << "Missing required parameter algorithm" << std::endl << std::endl; + print_options(std::cout, argv[0]); + return 1; + } + if(!params.use_serial && !params.use_threads && !params.use_openmp && !params.use_cuda) + { + print_options(std::cout, argv[0]); + return 1; + } + return 0; +} + +namespace KokkosKernels { +namespace Experiment { + + +template +void run_experiment(crsGraph_t crsGraph, Parameters params) +{ + using namespace KokkosGraph; + using namespace KokkosGraph::Experimental; + + int algorithm = params.algorithm; + int repeat = params.repeat; + int chunk_size = params.chunk_size; + + int shmemsize = params.shmemsize; + int team_size = params.team_size; + int use_dynamic_scheduling = params.use_dynamic_scheduling; + int verbose = params.verbose; + + // char spgemm_step = params.spgemm_step; + int vector_size = params.vector_size; - // Timer products. - struct timeval begin, end; + typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; + typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; - gettimeofday( &begin, NULL ); + typedef typename lno_view_t::non_const_value_type size_type; + typedef typename lno_nnz_view_t::non_const_value_type lno_t; - std::cout << "Do stuff here!" << std::endl; + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; - gettimeofday( &end, NULL ); + // Note: crsGraph.numRows() == number of vertices in the 'graph' + // crsGraph.entries.extent(0) == number of edges in the 'graph' - // Calculate time. - double time = 1.0 * ( end.tv_sec - begin.tv_sec ) + 1.0e-6 * ( end.tv_usec - begin.tv_usec ); + std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; + + KernelHandle kh; + kh.set_team_work_size(chunk_size); + kh.set_shmem_size(shmemsize); + kh.set_suggested_team_size(team_size); + kh.set_suggested_vector_size(vector_size); + + if(use_dynamic_scheduling) + { + kh.set_dynamic_scheduling(true); + } + + if(verbose) + { + kh.set_verbose(true); + } + + // accumulators for average stats + double total_time = 0.0; + size_t total_colors = 0; + size_t total_phases = 0; + + std::string label_algorithm; + + for(int i = 0; i < repeat; ++i) + { + + switch(algorithm) + { + case 1: + // kh.create_graph_coloring_handle(COLORING_SPGEMM); + kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + break; + case 2: + kh.create_graph_coloring_handle(COLORING_D2); + label_algorithm = "COLORING_D2"; + break; + default: + kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + break; + } + + graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + + std::cout << "Time : " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl + << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl + << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; + std::cout << "\t"; + KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); + std::cout << std::endl; + + total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); + total_colors += kh.get_graph_coloring_handle()->get_num_colors(); + total_phases += kh.get_graph_coloring_handle()->get_num_phases(); + } - std::cout << "Time: " << time << std::endl; + double avg_time = total_time / repeat; + double avg_colors = total_colors / (double)repeat; + double avg_phases = total_phases / (double)repeat; -#if 0 - // Calculate bandwidth. - // Each matrix A row (each of length M) is read once. - // The x vector (of length M) is read N times. - // The y vector (of length N) is read once. - // double Gbytes = 1.0e-9 * double( sizeof(double) * ( 2 * M * N + N ) ); - double Gbytes = 1.0e-9 * double( sizeof(double) * ( M + M * N + N ) ); + std::string a_mtx_bin_file = params.a_mtx_bin_file; + a_mtx_bin_file = a_mtx_bin_file.substr(a_mtx_bin_file.find_last_of("/\\") + 1); - // Print results (problem size, time and bandwidth in GB/s). - printf( " N( %d ) M( %d ) nrepeat ( %d ) problem( %g MB ) time( %g s ) bandwidth( %g GB/s )\n", - N, M, nrepeat, Gbytes * 1000, time, Gbytes * nrepeat / time ); + std::cout << "Summary:" << std::endl + << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl + << " Filename : " << a_mtx_bin_file << std::endl + << " Num Verts : " << crsGraph.numRows() << std::endl + << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl + << " Concurrency: " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl + << " Algorithm : " << label_algorithm << std::endl + << " Avg Time : " << avg_time << std::endl + << " Avg colors : " << avg_colors << std::endl + << " Avg Phases : " << avg_phases << std::endl + << std::endl; - delete[] A; - delete[] y; - delete[] x; -#endif + std::cout << "CSVHDR" + << "," << "Filename" + << "," << "Num Rows" + << "," << "Num Edges" + << "," << "Execution Space" + << "," << "Concurrency" + << "," << "Algorithm" + << "," << "Avg Time" + << "," << "Avg Colors" + << "," << "Avg Num Phases" + << std::endl; - Kokkos::finalize(); - return 0; + std::cout << "CSVDATA" + << "," << a_mtx_bin_file + << "," << crsGraph.numRows() + << "," << crsGraph.entries.dimension_0() + << "," << Kokkos::DefaultExecutionSpace::name() + << "," << Kokkos::DefaultExecutionSpace::concurrency() + << "," << label_algorithm + << "," << avg_time + << "," << avg_colors + << "," << avg_phases + << std::endl; + + // Kokkos::print_configuration(std::cout); +} + + +template +void run_multi_mem_experiment(Parameters params) +{ + + typedef exec_space myExecSpace; + typedef Kokkos::Device myFastDevice; + typedef Kokkos::Device mySlowExecSpace; + + typedef typename MyKokkosSparse::CrsMatrix fast_crstmat_t; + typedef typename fast_crstmat_t::StaticCrsGraphType fast_graph_t; + // typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; + // typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; + + // typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; + // typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; + + typedef typename MyKokkosSparse::CrsMatrix slow_crstmat_t; + typedef typename slow_crstmat_t::StaticCrsGraphType slow_graph_t; + + // typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; + // typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; + // typedef typename slow_graph_t::row_map_type::const_type const_slow_row_map_view_t; + // typedef typename slow_graph_t::entries_type::const_type const_slow_cols_view_t; + + char *a_mat_file = params.a_mtx_bin_file; + + slow_graph_t a_slow_crsgraph, /*b_slow_crsgraph,*/ c_slow_crsgraph; + fast_graph_t a_fast_crsgraph, /*b_fast_crsgraph,*/ c_fast_crsgraph; + + // read a and b matrices and store them on slow or fast memory. + if(params.a_mem_space == 1) + { + fast_crstmat_t a_fast_crsmat; + a_fast_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); + a_fast_crsgraph = a_fast_crsmat.graph; + a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); + } + else + { + slow_crstmat_t a_slow_crsmat; + a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); + a_slow_crsgraph = a_slow_crsmat.graph; + a_slow_crsgraph.num_cols = a_slow_crsmat.numCols(); + } + + if(params.a_mem_space == 1) + { + if(params.b_mem_space == 1) + { + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + } + else + { + // B is in slow memory + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + } + } + else + { + // A is in slow memory + if(params.b_mem_space == 1) + { + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + } + else + { + // B is in slow memory + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + } + } } + +} // namespace Experiment +} // namespace KokkosKernels + + + + + +int main(int argc, char *argv[]) +{ + KokkosKernels::Experiment::Parameters params; + + if(parse_inputs(params, argc, argv)) + { + return 1; + } + + if(params.a_mtx_bin_file == NULL) + { + std::cerr << "Provide a matrix file" << std::endl; + return 0; + } + + std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl + << "Sizeof(size_type): " << sizeof(kk_size_type) << std::endl; + + const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads + const int device_id = 0; + Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); + Kokkos::print_configuration(std::cout); + +#if defined(KOKKOS_ENABLE_OPENMP) + if(params.use_openmp) + { +#ifdef KOKKOSKERNELS_MULTI_MEM + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#else + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#endif + } +#endif + + +#if defined(KOKKOS_ENABLE_CUDA) + if(params.use_cuda) + { +#ifdef KOKKOSKERNELS_MULTI_MEM + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#else + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#endif + } +#endif + + +#if defined(KOKKOS_ENABLE_SERIAL) + if(params.use_serial) + { +#ifdef KOKKOSKERNELS_MULTI_MEM + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#else + KokkosKernels::Experiment::run_multi_mem_experiment(params); +#endif + } +#endif + + /* + // Timer products. + struct timeval begin, end; + + gettimeofday(&begin, NULL); + + std::cout << "Do stuff here!" << std::endl; + + gettimeofday(&end, NULL); + + // Calculate time. + double time = 1.0 * (end.tv_sec - begin.tv_sec) + 1.0e-6 * (end.tv_usec - begin.tv_usec); + + std::cout << "Time: " << time << std::endl; + */ + + Kokkos::finalize(); + + return 0; +} From 0325339d1e43ec7d74be535fe553bfda09052139 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 May 2018 23:36:11 -0600 Subject: [PATCH 008/190] Style fixes to Distance2Color impl file --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 1488 ++++++++--------- 1 file changed, 717 insertions(+), 771 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 1810520cbe..0bbe0ce522 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -43,15 +43,15 @@ #include #include -#include -#include #include -#include +#include +#include #include +#include -#include "KokkosKernels_Handle.hpp" #include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosGraph_graph_color.hpp" +#include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2IMP_HPP #define _KOKKOSCOLORINGD2IMP_HPP @@ -74,140 +74,130 @@ namespace Impl { * e.g. no vertex having same color shares an edge. * General aim is to find the minimum number of colors, minimum number of independent sets. */ -template +template class GraphColorD2_MatrixSquared { -public: - - typedef lno_row_view_t_ in_lno_row_view_t; - typedef lno_nnz_view_t_ in_lno_nnz_view_t; - - typedef typename HandleType::GraphColoringHandleType::color_t color_t; - typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; - - typedef typename HandleType::size_type size_type; - typedef typename HandleType::nnz_lno_t nnz_lno_t; - - typedef typename HandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::const_size_type const_size_type; - - typedef typename lno_row_view_t_::device_type row_lno_view_device_t; - typedef typename lno_row_view_t_::const_type const_lno_row_view_t; - typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; - typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - - typedef typename clno_row_view_t_::const_type const_clno_row_view_t; - typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; - typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - - typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; - typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; - typedef typename HandleType::nnz_lno_persistent_work_view_t nnz_lno_persistent_work_view_t; - - typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; - typedef typename Kokkos::View single_dim_index_view_type; - - typedef Kokkos::RangePolicy my_exec_space; - - -protected: - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) - const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap - const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - HandleType* cp; // the handle. - -public: - - /** - * \brief GraphColor constructor. - * \param nv_: number of vertices in the graph - * \param ne_: number of edges in the graph - * \param row_map: the xadj array of the graph. Its size is nv_ +1 - * \param entries: adjacency array of the graph. Its size is ne_ - * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, - * including parameters. - */ - GraphColorD2_MatrixSquared (nnz_lno_t nr_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType* handle): - nr (nr_), - nc (nc_), - ne(ne_), - xadj(row_map), - adj(entries), - t_xadj(t_row_map), - t_adj(t_entries), - nv (nr_), - cp(handle) - {} - - - /** \brief GraphColor destructor. - */ - virtual ~GraphColorD2_MatrixSquared () - {} - - - /** \brief Function to color the vertices of the graphs. This is the base class, - * therefore, it only performs sequential coloring on the host device, ignoring the execution space. - * \param colors is the output array corresponding the color of each vertex.Size is this->nv. - * Attn: Color array must be nonnegative numbers. If there is no initial colors, - * it should be all initialized with zeros. Any positive value in the given array, will make the - * algorithm to assume that the color is fixed for the corresponding vertex. - * \param num_phases: The number of iterations (phases) that algorithm takes to converge. - */ - virtual void color_graph_d2_matrix_squared() - { - std::string algName = "SPGEMM_KK_MEMSPEED"; - cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); - - size_type_temp_work_view_t cRowptrs("cRowptrs", nr+1); - - // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) - KokkosSparse::Experimental::spgemm_symbolic(cp, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); - - // Get num nz in C - auto Cnnz = cp->get_spgemm_handle()->get_c_nnz(); - - // Must create placeholder value views for A and C (values are meaningless) - // Said above that the scalar view type is the same as the colinds view type - scalar_temp_work_view_t aFakeValues("A/B placeholder values (meaningless)", adj.size()); - - // Allocate C entries array, and placeholder values - nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); - scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); - - // Run the numeric kernel - KokkosSparse::Experimental::spgemm_numeric(cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, - aFakeValues, false, cRowptrs, cColinds, cFakeValues); - - // done with spgemm - cp->destroy_spgemm_handle(); - - // Now run distance-1 graph coloring on C - // Use LocalOrdinal for storing colors - KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); - - // extract the colors - //auto coloringHandle = cp->get_graph_coloring_handle(); - //color_view_type colorsDevice = coloringHandle->get_vertex_colors(); - - //clean up coloring handle - // cp->destroy_graph_coloring_handle(); - } - -}; // GraphColorD2_MatrixSquared (end) + public: + typedef lno_row_view_t_ in_lno_row_view_t; + typedef lno_nnz_view_t_ in_lno_nnz_view_t; + + typedef typename HandleType::GraphColoringHandleType::color_t color_t; + typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; + + typedef typename HandleType::size_type size_type; + typedef typename HandleType::nnz_lno_t nnz_lno_t; + + typedef typename HandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; + typedef typename HandleType::const_size_type const_size_type; + + typedef typename lno_row_view_t_::device_type row_lno_view_device_t; + typedef typename lno_row_view_t_::const_type const_lno_row_view_t; + typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; + typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; + + typedef typename clno_row_view_t_::const_type const_clno_row_view_t; + typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; + typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; + + typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; + typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; + typedef typename HandleType::nnz_lno_persistent_work_view_t nnz_lno_persistent_work_view_t; + + typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename Kokkos::View single_dim_index_view_type; + + typedef Kokkos::RangePolicy my_exec_space; + + + protected: + nnz_lno_t nr; // num_rows (# verts) + nnz_lno_t nc; // num cols + size_type ne; // # edges + const_lno_row_view_t xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) + const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap + const_clno_nnz_view_t t_adj; // entries, transpose of entries + nnz_lno_t nv; // num vertices + HandleType *cp; // the handle. + + public: + /** + * \brief GraphColor constructor. + * \param nv_: number of vertices in the graph + * \param ne_: number of edges in the graph + * \param row_map: the xadj array of the graph. Its size is nv_ +1 + * \param entries: adjacency array of the graph. Its size is ne_ + * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, + * including parameters. + */ + GraphColorD2_MatrixSquared(nnz_lno_t nr_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, + const_clno_row_view_t t_row_map, + const_clno_nnz_view_t t_entries, + HandleType *handle) + : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle) + { + } + + + /** \brief GraphColor destructor. + */ + virtual ~GraphColorD2_MatrixSquared() {} + + + /** \brief Function to color the vertices of the graphs. This is the base class, + * therefore, it only performs sequential coloring on the host device, ignoring the execution space. + * \param colors is the output array corresponding the color of each vertex.Size is this->nv. + * Attn: Color array must be nonnegative numbers. If there is no initial colors, + * it should be all initialized with zeros. Any positive value in the given array, will make the + * algorithm to assume that the color is fixed for the corresponding vertex. + * \param num_phases: The number of iterations (phases) that algorithm takes to converge. + */ + virtual void color_graph_d2_matrix_squared() + { + std::string algName = "SPGEMM_KK_MEMSPEED"; + cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); + + size_type_temp_work_view_t cRowptrs("cRowptrs", nr + 1); + + // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) + KokkosSparse::Experimental::spgemm_symbolic(cp, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); + + // Get num nz in C + auto Cnnz = cp->get_spgemm_handle()->get_c_nnz(); + + // Must create placeholder value views for A and C (values are meaningless) + // Said above that the scalar view type is the same as the colinds view type + scalar_temp_work_view_t aFakeValues("A/B placeholder values (meaningless)", adj.size()); + + // Allocate C entries array, and placeholder values + nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); + scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + + // Run the numeric kernel + KokkosSparse::Experimental::spgemm_numeric( + cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); + + // done with spgemm + cp->destroy_spgemm_handle(); + + // Now run distance-1 graph coloring on C + // Use LocalOrdinal for storing colors + KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); + + // extract the colors + // auto coloringHandle = cp->get_graph_coloring_handle(); + // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); + + // clean up coloring handle + // cp->destroy_graph_coloring_handle(); + } + +}; // GraphColorD2_MatrixSquared (end) @@ -216,723 +206,679 @@ class GraphColorD2_MatrixSquared * e.g. no vertex having same color shares an edge. * General aim is to find the minimum number of colors, minimum number of independent sets. */ -template +template class GraphColorD2 { -public: - - typedef lno_row_view_t_ in_lno_row_view_t; - typedef lno_nnz_view_t_ in_lno_nnz_view_t; - - typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; - typedef typename HandleType::GraphColoringHandleType::color_t color_t; - - typedef typename HandleType::GraphColoringHandleType::size_type size_type; - typedef typename HandleType::GraphColoringHandleType::nnz_lno_t nnz_lno_t; - - typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type - typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type - typedef typename HandleType::GraphColoringHandleType::color_host_view_t color_host_view_t; // host view type - - typedef typename HandleType::GraphColoringHandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::GraphColoringHandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::GraphColoringHandleType::const_size_type const_size_type; - - typedef typename lno_row_view_t_::device_type row_lno_view_device_t; - typedef typename lno_row_view_t_::const_type const_lno_row_view_t; - typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; - typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - - typedef typename clno_row_view_t_::const_type const_clno_row_view_t; - typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; - typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - - typedef typename HandleType::GraphColoringHandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; - typedef typename Kokkos::View single_dim_index_view_type; - - typedef Kokkos::RangePolicy my_exec_space; - - -protected: - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) - const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap - const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - - typename HandleType::GraphColoringHandleType* cp; // pointer to the graph coloring handle - -private: - - int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs - int _max_num_iterations; - char _conflictList; // 0: none, 1: atomic (default), 2: parallel prefix sums (0, 2 not implemented) - bool _serialConflictResolution; // true if using serial conflict resolution, false otherwise (default) - char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). - bool _ticToc; // if true print info in each step - -public: - - /** - * \brief GraphColor constructor. - * \param nv_: number of vertices in the graph - * \param ne_: number of edges in the graph - * \param row_map: the xadj array of the graph. Its size is nv_ +1 - * \param entries: adjacency array of the graph. Its size is ne_ - * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, - * including parameters. - */ - GraphColorD2 (nnz_lno_t nr_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType* handle): - nr (nr_), - nc (nc_), - ne(ne_), - xadj(row_map), - adj(entries), - t_xadj(t_row_map), - t_adj(t_entries), - nv (nr_), - cp(handle->get_graph_coloring_handle()), - _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), - _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), - _conflictList(1), - _serialConflictResolution(false), - _use_color_set(0), - _ticToc(handle->get_verbose()) - { - //std::cout << ">>> WCMCLEN GraphColorD2() (KokkosGraph_Distance2Color_impl.hpp)" << std::endl - // << ">>> WCMCLEN : coloring_algo_type = " << handle->get_coloring_algo_type() << std::endl - // << ">>> WCMCLEN : conflict_list_type = " << handle->get_conflict_list_type() << std::endl; - } - - - /** \brief GraphColor destructor. - */ - virtual ~GraphColorD2 () - {} - - - // ----------------------------------------------------------------- - // - // GraphColorD2::color_graph_d2() - // - // ----------------------------------------------------------------- - virtual void color_graph_d2() - { - - color_view_type colors_out("Graph Colors", this->nv); - - // Data: - // cp = graph coloring handle - // nr = num_rows (scalar) - // nc = num_cols (scalar) - // xadj = row_map (view 1 dimension - [num_verts+1] - entries index into adj ) - // adj = entries (view 1 dimension - [num_edges] - adjacency list ) - - if(this->_ticToc) - { - std::cout << "\tcolor_graph_d2 params:" << std::endl - << "\t algorithm : " << (int) this->_use_color_set << std::endl - << "\t useConflictList : " << (int) this->_conflictList << std::endl - << "\t ticToc : " << this->_ticToc << std::endl - << "\t max_num_iterations : " << this->_max_num_iterations << std::endl - << "\t serialConflictResolution : " << (int) this->_serialConflictResolution << std::endl - << "\t chunkSize : " << this->_chunkSize << std::endl - << "\t use_color_set : " << (int) this->_use_color_set << std::endl - << "\tgraph information:" << std::endl - << "\t nv : " << this->nv << std::endl - << "\t ne : " << this->ne << std::endl; - } + public: + typedef lno_row_view_t_ in_lno_row_view_t; + typedef lno_nnz_view_t_ in_lno_nnz_view_t; - //prettyPrint1DView(this->xadj, ">>> WCMCLEN xadj ", 500); - //prettyPrint1DView(this->adj, ">>> WCMCLEN adj ", 500); + typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; + typedef typename HandleType::GraphColoringHandleType::color_t color_t; - // conflictlist - store conflicts that can happen when we're coloring in parallel. - nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); + typedef typename HandleType::GraphColoringHandleType::size_type size_type; + typedef typename HandleType::GraphColoringHandleType::nnz_lno_t nnz_lno_t; - // init conflictlist sequentially. - Kokkos::parallel_for(my_exec_space(0, this->nv), functorInitList(current_vertexList)); + typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type + typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type + typedef typename HandleType::GraphColoringHandleType::color_host_view_t color_host_view_t; // host view type - // Next iteratons's conflictList - nnz_lno_temp_work_view_t next_iteration_recolorList; + typedef typename HandleType::GraphColoringHandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::GraphColoringHandleType::HandleTempMemorySpace MyTempMemorySpace; + typedef typename HandleType::GraphColoringHandleType::const_size_type const_size_type; - // Size the next iteration conflictList - single_dim_index_view_type next_iteration_recolorListLength; + typedef typename lno_row_view_t_::device_type row_lno_view_device_t; + typedef typename lno_row_view_t_::const_type const_lno_row_view_t; + typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; + typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - // if we're using a conflictList - if(this->_conflictList > 0) - { - // Vertices to recolor. Will swap with vertexList - next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); - next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); - } + typedef typename clno_row_view_t_::const_type const_clno_row_view_t; + typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; + typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - nnz_lno_t numUncolored = this->nv; - nnz_lno_t current_vertexListLength = this->nv; + typedef typename HandleType::GraphColoringHandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename Kokkos::View single_dim_index_view_type; - double t, total=0.0; - Kokkos::Impl::Timer timer; + typedef Kokkos::RangePolicy my_exec_space; - int iter=0; - for (; (iter < _max_num_iterations) && (numUncolored>0); iter++) - { - // Do greedy color - this->colorGreedy(this->xadj, - this->adj, - this->t_xadj, - this->t_adj, - colors_out, - current_vertexList, - current_vertexListLength); - - MyExecSpace::fence(); - - if(this->_ticToc) - { - t = timer.seconds(); - total += t; - std::cout << "\tTime speculative greedy phase " << std::setw(-2) << iter << " : " << t << std::endl; - timer.reset(); - } - - //prettyPrint1DView(colors_out, ">>> WCMCLEN colors_out", 100); - - // Find conflicts - bool swap_work_arrays = true; // NOTE: swap_work_arrays can go away in this example -- was only ever - // set false in the PPS code in the original D1 coloring... - - // NOTE: not using colorset algorithm in this so we don't include colorset data - numUncolored = this->findConflicts(swap_work_arrays, - this->xadj, - this->adj, - this->t_xadj, - this->t_adj, - colors_out, - current_vertexList, - current_vertexListLength, - next_iteration_recolorList, - next_iteration_recolorListLength); - - MyExecSpace::fence(); - - if (_ticToc) - { - t = timer.seconds(); - total += t; - std::cout << "\tTime conflict detection " << std::setw(-2) << iter << " : " << t << std::endl; - timer.reset(); - } - - // If conflictList is used and we need to swap the work arrays - if(this->_conflictList && swap_work_arrays) - { - // Swap Work Arrays - if(iter+1 < this->_max_num_iterations) - { - nnz_lno_temp_work_view_t temp = current_vertexList; - current_vertexList = next_iteration_recolorList; - next_iteration_recolorList = temp; - current_vertexListLength = numUncolored; - next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); - } - } - } // end for iter... + protected: + nnz_lno_t nr; // num_rows (# verts) + nnz_lno_t nc; // num cols + size_type ne; // # edges + const_lno_row_view_t xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) + const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap + const_clno_nnz_view_t t_adj; // entries, transpose of entries + nnz_lno_t nv; // num vertices + + typename HandleType::GraphColoringHandleType *cp; // pointer to the graph coloring handle + + private: + int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs + int _max_num_iterations; + char _conflictList; // 0: none, 1: atomic (default), 2: parallel prefix sums (0, 2 not implemented) + bool _serialConflictResolution; // true if using serial conflict resolution, false otherwise (default) + char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). + bool _ticToc; // if true print info in each step - // clean up in serial - if (numUncolored > 0) + public: + /** + * \brief GraphColor constructor. + * \param nv_: number of vertices in the graph + * \param ne_: number of edges in the graph + * \param row_map: the xadj array of the graph. Its size is nv_ +1 + * \param entries: adjacency array of the graph. Its size is ne_ + * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, + * including parameters. + */ + GraphColorD2(nnz_lno_t nr_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, + const_clno_row_view_t t_row_map, + const_clno_nnz_view_t t_entries, + HandleType *handle) + : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), + cp(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), + _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1), + _serialConflictResolution(false), _use_color_set(0), _ticToc(handle->get_verbose()) { - this->resolveConflicts(this->nv, - this->xadj, - this->adj, - this->t_xadj, - this->t_adj, - colors_out, - current_vertexList, - current_vertexListLength); + // std::cout << ">>> WCMCLEN GraphColorD2() (KokkosGraph_Distance2Color_impl.hpp)" << std::endl + // << ">>> WCMCLEN : coloring_algo_type = " << handle->get_coloring_algo_type() << std::endl + // << ">>> WCMCLEN : conflict_list_type = " << handle->get_conflict_list_type() << std::endl; } - MyExecSpace::fence(); - if (_ticToc) + /** \brief GraphColor destructor. + */ + virtual ~GraphColorD2() {} + + + // ----------------------------------------------------------------- + // + // GraphColorD2::color_graph_d2() + // + // ----------------------------------------------------------------- + virtual void color_graph_d2() { - t = timer.seconds(); - total += t; - std::cout << "\tTime serial conflict resolution : " << t << std::endl; - } - // Save out the number of phases and vertex colors - this->cp->set_vertex_colors( colors_out ); - this->cp->set_num_phases( (double)iter ); + color_view_type colors_out("Graph Colors", this->nv); - } // color_graph_d2 (end) + // Data: + // cp = graph coloring handle + // nr = num_rows (scalar) + // nc = num_cols (scalar) + // xadj = row_map (view 1 dimension - [num_verts+1] - entries index into adj ) + // adj = entries (view 1 dimension - [num_edges] - adjacency list ) + if(this->_ticToc) + { + std::cout << "\tcolor_graph_d2 params:" << std::endl + << "\t algorithm : " << (int)this->_use_color_set << std::endl + << "\t useConflictList : " << (int)this->_conflictList << std::endl + << "\t ticToc : " << this->_ticToc << std::endl + << "\t max_num_iterations : " << this->_max_num_iterations << std::endl + << "\t serialConflictResolution : " << (int)this->_serialConflictResolution << std::endl + << "\t chunkSize : " << this->_chunkSize << std::endl + << "\t use_color_set : " << (int)this->_use_color_set << std::endl + << "\tgraph information:" << std::endl + << "\t nv : " << this->nv << std::endl + << "\t ne : " << this->ne << std::endl; + } + // prettyPrint1DView(this->xadj, ">>> WCMCLEN xadj ", 500); + // prettyPrint1DView(this->adj, ">>> WCMCLEN adj ", 500); -private: + // conflictlist - store conflicts that can happen when we're coloring in parallel. + nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); + // init conflictlist sequentially. + Kokkos::parallel_for(my_exec_space(0, this->nv), functorInitList(current_vertexList)); - // ----------------------------------------------------------------- - // - // GraphColorD2::colorGreedy() - // - // ----------------------------------------------------------------- - void colorGreedy(const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - nnz_lno_t current_vertexListLength_) - { - //std::cout << ">>> WCMCLEN colorGreedy (KokkosGraph_Distance2Color_impl.hpp) <<<" << std::endl; - nnz_lno_t chunkSize_ = this->_chunkSize; + // Next iteratons's conflictList + nnz_lno_temp_work_view_t next_iteration_recolorList; - if (current_vertexListLength_ < 100*chunkSize_) - { - chunkSize_ = 1; - } + // Size the next iteration conflictList + single_dim_index_view_type next_iteration_recolorListLength; - functorGreedyColor gc(this->nv, - xadj_, - adj_, - t_xadj_, - t_adj_, - vertex_colors_, - current_vertexList_, - current_vertexListLength_, - chunkSize_ - ); - - Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); - - } // colorGreedy (end) - - - - // ----------------------------------------------------------------- - // - // GraphColorD2::findConflicts() - // - // ----------------------------------------------------------------- - // NOTE: not using colorset algorithm in this so we don't include colorset data - template - nnz_lno_t findConflicts(bool& swap_work_arrays, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - nnz_lno_t current_vertexListLength_, - nnz_lno_temp_work_view_t next_iteration_recolorList_, - single_dim_index_view_type next_iteration_recolorListLength_ - ) - { - swap_work_arrays = true; - nnz_lno_t output_numUncolored = 0; - - // conflictList mode: - if(0 == this->_conflictList) - { - // Throw an error -- not implemented (yet) - std::ostringstream os; - os << "GraphColorD2::findConflicts() not implemented for conflictList == 0"; - Kokkos::Impl::throw_runtime_exception(os.str()); - } + // if we're using a conflictList + if(this->_conflictList > 0) + { + // Vertices to recolor. Will swap with vertexList + next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); + next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); + } - // conflictList mode: Parallel Prefix Sums (PPS) - else if(2 == this->_conflictList) - { - // Throw an error -- not implemented (yet) - std::ostringstream os; - os << "GraphColorD2::findConflicts() not implemented for conflictList == 2"; - Kokkos::Impl::throw_runtime_exception(os.str()); - } + nnz_lno_t numUncolored = this->nv; + nnz_lno_t current_vertexListLength = this->nv; - // conflictList mode: ATOMIC - else if(1 == this->_conflictList) - { - if(0 == this->_use_color_set) - { - functorFindConflicts_Atomic conf(this->nv, - xadj_, - adj_, - t_xadj_, - t_adj_, - vertex_colors_, - current_vertexList_, - next_iteration_recolorList_, - next_iteration_recolorListLength_); - Kokkos::parallel_reduce(my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); - } - } - else - { - // Throw an error becaue we should not be here... - std::ostringstream os; - os << "GraphColorD2::findConflicts() - unknown conflictList Flag value: " << this->_conflictList << " "; - Kokkos::Impl::throw_runtime_exception(os.str()); - } - return output_numUncolored; - } // findConflicts (end) - - - - // ----------------------------------------------------------------- - // - // GraphColorD2::resolveConflicts() - // - // ----------------------------------------------------------------- - template - void resolveConflicts(nnz_lno_t _nv, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - size_type current_vertexListLength_) - { - color_t* forbidden = new color_t[_nv]; - nnz_lno_t vid = 0; - nnz_lno_t end = _nv; - - typename nnz_lno_temp_work_view_t::HostMirror h_recolor_list; - - if(this->_conflictList) - { - end = current_vertexListLength_; - h_recolor_list = Kokkos::create_mirror_view(current_vertexList_); - Kokkos::deep_copy(h_recolor_list, current_vertexList_); - } + double t, total = 0.0; + Kokkos::Impl::Timer timer; - color_host_view_t h_colors = Kokkos::create_mirror_view(vertex_colors_); + int iter = 0; + for(; (iter < _max_num_iterations) && (numUncolored > 0); iter++) + { + // Do greedy color + this->colorGreedy(this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); - typename const_lno_row_view_t::HostMirror h_idx = Kokkos::create_mirror_view(xadj_); - typename adj_view_t::HostMirror h_adj = Kokkos::create_mirror_view(adj_); + MyExecSpace::fence(); - typename const_clno_row_view_t::HostMirror h_t_idx = Kokkos::create_mirror_view(t_xadj_); - typename const_clno_nnz_view_t::HostMirror h_t_adj = Kokkos::create_mirror_view(t_adj_); + if(this->_ticToc) + { + t = timer.seconds(); + total += t; + std::cout << "\tTime speculative greedy phase " << std::setw(-2) << iter << " : " << t << std::endl; + timer.reset(); + } - Kokkos::deep_copy(h_colors, vertex_colors_); + // prettyPrint1DView(colors_out, ">>> WCMCLEN colors_out", 100); - Kokkos::deep_copy(h_idx, xadj_); - Kokkos::deep_copy(h_adj, adj_); + // Find conflicts + bool swap_work_arrays = true; // NOTE: swap_work_arrays can go away in this example -- was only ever + // set false in the PPS code in the original D1 coloring... - Kokkos::deep_copy(h_t_idx, t_xadj_); - Kokkos::deep_copy(h_t_adj, t_adj_); + // NOTE: not using colorset algorithm in this so we don't include colorset data + numUncolored = this->findConflicts(swap_work_arrays, + this->xadj, + this->adj, + this->t_xadj, + this->t_adj, + colors_out, + current_vertexList, + current_vertexListLength, + next_iteration_recolorList, + next_iteration_recolorListLength); - for(nnz_lno_t k=0; k_conflictList) - { - vid = h_recolor_list(k); - } - else - { - vid = k; // check for uncolored vertices - } - - if(h_colors(vid) > 0) continue; - - // loop over distance-1 neighbors of vid - for(size_type vid_1adj=h_idx(vid); vid_1adj < h_idx(vid+1); vid_1adj++) - { - size_type vid_1idx = h_adj(vid_1adj); - - // loop over distance-1 neighbors of vid_1idx (distance-2 from vid) - for(size_type vid_2adj=h_t_idx(vid_1idx); vid_2adj < h_t_idx(vid_1idx+1); vid_2adj++) - { - nnz_lno_t vid_2idx = h_t_adj(vid_2adj); + MyExecSpace::fence(); - // skip over loops vid -- x -- vid - if(vid_2idx == vid) - continue; + if(_ticToc) + { + t = timer.seconds(); + total += t; + std::cout << "\tTime conflict detection " << std::setw(-2) << iter << " : " << t << std::endl; + timer.reset(); + } + + // If conflictList is used and we need to swap the work arrays + if(this->_conflictList && swap_work_arrays) + { + // Swap Work Arrays + if(iter + 1 < this->_max_num_iterations) + { + nnz_lno_temp_work_view_t temp = current_vertexList; + current_vertexList = next_iteration_recolorList; + next_iteration_recolorList = temp; + + current_vertexListLength = numUncolored; + next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); + } + } + } // end for iter... - forbidden[h_colors(vid_2idx)] = vid; + // clean up in serial + if(numUncolored > 0) + { + this->resolveConflicts( + this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } - } - // color vertex vid with smallest available color - int c=1; - while (forbidden[c]==vid) c++; + MyExecSpace::fence(); - h_colors(vid) = c; - } - Kokkos::deep_copy(vertex_colors_, h_colors); - delete [] forbidden; - } // resolveConflicts (end) + if(_ticToc) + { + t = timer.seconds(); + total += t; + std::cout << "\tTime serial conflict resolution : " << t << std::endl; + } + + // Save out the number of phases and vertex colors + this->cp->set_vertex_colors(colors_out); + this->cp->set_num_phases((double)iter); + } // color_graph_d2 (end) - // ------------------------------------------------------ - // Functors: Helpers - // ------------------------------------------------------ - // pretty-print a 1D View with label - template - void prettyPrint1DView(kokkos_view_t & view, const char* label, const size_t max_entries=500) const - { - int max_per_line=20; - int line_count=1; - std::cout << label << " = [ \n\t"; - for(size_t i=0; i= max_per_line) { - std::cout << std::endl << "\t"; - line_count = 0; - } - line_count++; - if(i >= max_entries-1) { std::cout << ""; break; } - } - if(line_count > 1) - std::cout << std::endl; - std::cout << "\t ]" << std::endl; - } // prettyPrint1DView (end) + // std::cout << ">>> WCMCLEN colorGreedy (KokkosGraph_Distance2Color_impl.hpp) <<<" << std::endl; + nnz_lno_t chunkSize_ = this->_chunkSize; + if(current_vertexListLength_ < 100 * chunkSize_) + { + chunkSize_ = 1; + } + functorGreedyColor gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - // ------------------------------------------------------ - // Functors: Distance-2 Graph Coloring - // ------------------------------------------------------ + Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); + + } // colorGreedy (end) - public: - /** - * Functor to init a list sequentialy, that is list[i] = i - */ - template - struct functorInitList - { - view_type _vertexList; - functorInitList (view_type vertexList) : _vertexList(vertexList) { } - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t i) const - { - // Natural order - _vertexList(i) = i; - } - }; // struct functorInitList (end) - - - - /** - * Functor for VB algorithm speculative coloring without edge filtering. - */ - struct functorGreedyColor - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColor(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), - _idx(xadj_), - _adj(adj_), - _t_idx(t_xadj_), - _t_adj(t_adj_), - _colors(colors), - _vertexList(vertexList), - _vertexListLength(vertexListLength), - _chunkSize(chunkSize) - { - } - // Color vertex i with smallest available color. + // ----------------------------------------------------------------- // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // GraphColorD2::findConflicts() // - // This version uses a bool array of size FORBIDDEN_SIZE. + // ----------------------------------------------------------------- + // NOTE: not using colorset algorithm in this so we don't include colorset data + template + nnz_lno_t findConflicts(bool &swap_work_arrays, + const_lno_row_view_t xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + nnz_lno_t current_vertexListLength_, + nnz_lno_temp_work_view_t next_iteration_recolorList_, + single_dim_index_view_type next_iteration_recolorListLength_) + { + swap_work_arrays = true; + nnz_lno_t output_numUncolored = 0; + + // conflictList mode: + if(0 == this->_conflictList) + { + // Throw an error -- not implemented (yet) + std::ostringstream os; + os << "GraphColorD2::findConflicts() not implemented for conflictList == 0"; + Kokkos::Impl::throw_runtime_exception(os.str()); + } + + // conflictList mode: Parallel Prefix Sums (PPS) + else if(2 == this->_conflictList) + { + // Throw an error -- not implemented (yet) + std::ostringstream os; + os << "GraphColorD2::findConflicts() not implemented for conflictList == 2"; + Kokkos::Impl::throw_runtime_exception(os.str()); + } + + // conflictList mode: ATOMIC + else if(1 == this->_conflictList) + { + if(0 == this->_use_color_set) + { + functorFindConflicts_Atomic conf(this->nv, + xadj_, + adj_, + t_xadj_, + t_adj_, + vertex_colors_, + current_vertexList_, + next_iteration_recolorList_, + next_iteration_recolorListLength_); + Kokkos::parallel_reduce(my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); + } + } + else + { + // Throw an error becaue we should not be here... + std::ostringstream os; + os << "GraphColorD2::findConflicts() - unknown conflictList Flag value: " << this->_conflictList << " "; + Kokkos::Impl::throw_runtime_exception(os.str()); + } + return output_numUncolored; + } // findConflicts (end) + + + + // ----------------------------------------------------------------- // - // param: ii = vertex id + // GraphColorD2::resolveConflicts() // - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_) const + // ----------------------------------------------------------------- + template + void resolveConflicts(nnz_lno_t _nv, + const_lno_row_view_t xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + size_type current_vertexListLength_) { - //std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; - nnz_lno_t vid = 0; - for (nnz_lno_t ichunk=0; ichunk < _chunkSize; ichunk++) - { - if (vid_ * _chunkSize + ichunk < _vertexListLength) - vid = _vertexList(vid_ * _chunkSize + ichunk); - else - continue; + color_t *forbidden = new color_t[_nv]; + nnz_lno_t vid = 0; + nnz_lno_t end = _nv; + + typename nnz_lno_temp_work_view_t::HostMirror h_recolor_list; + + if(this->_conflictList) + { + end = current_vertexListLength_; + h_recolor_list = Kokkos::create_mirror_view(current_vertexList_); + Kokkos::deep_copy(h_recolor_list, current_vertexList_); + } + + color_host_view_t h_colors = Kokkos::create_mirror_view(vertex_colors_); + + typename const_lno_row_view_t::HostMirror h_idx = Kokkos::create_mirror_view(xadj_); + typename adj_view_t::HostMirror h_adj = Kokkos::create_mirror_view(adj_); - // Already colored this vertex. - if(_colors(vid) > 0) { continue; } + typename const_clno_row_view_t::HostMirror h_t_idx = Kokkos::create_mirror_view(t_xadj_); + typename const_clno_nnz_view_t::HostMirror h_t_adj = Kokkos::create_mirror_view(t_adj_); - bool foundColor = false; // Have we found a valid color? + Kokkos::deep_copy(h_colors, vertex_colors_); - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + Kokkos::deep_copy(h_idx, xadj_); + Kokkos::deep_copy(h_adj, adj_); - // Do multiple passes if the array is too small. - // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. - // This could be as big as all the vertices in the graph if diameter(G)=2... - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; + Kokkos::deep_copy(h_t_idx, t_xadj_); + Kokkos::deep_copy(h_t_adj, t_adj_); - while(!foundColor) + for(nnz_lno_t k = 0; k < end; k++) { - // initialize - for(int j=0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) - { - forbidden[j] = false; - } - // by convention, start at 1 - if(offset == 0) - { - forbidden[0] = true; - } - - // Check neighbors, fill forbidden array. - for(size_type vid_1adj=_idx(vid); vid_1adj < _idx(vid+1); vid_1adj++) - { - nnz_lno_t vid_1idx = _adj(vid_1adj); - - for(size_type vid_2adj=_t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx+1); vid_2adj++) + if(this->_conflictList) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); + vid = h_recolor_list(k); + } + else + { + vid = k; // check for uncolored vertices + } - // Skip distance-2-self-loops - if(vid_2idx == vid || vid_2idx >= nv) - { + if(h_colors(vid) > 0) continue; - } - color_t c = _colors(vid_2idx); + // loop over distance-1 neighbors of vid + for(size_type vid_1adj = h_idx(vid); vid_1adj < h_idx(vid + 1); vid_1adj++) + { + size_type vid_1idx = h_adj(vid_1adj); + + // loop over distance-1 neighbors of vid_1idx (distance-2 from vid) + for(size_type vid_2adj = h_t_idx(vid_1idx); vid_2adj < h_t_idx(vid_1idx + 1); vid_2adj++) + { + nnz_lno_t vid_2idx = h_t_adj(vid_2adj); - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - forbidden[c - offset] = true; - } + // skip over loops vid -- x -- vid + if(vid_2idx == vid) + continue; + + forbidden[h_colors(vid_2idx)] = vid; + } } - } - // color vertex i with smallest available color (firstFit) - for(int c=0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) + // color vertex vid with smallest available color + int c = 1; + while(forbidden[c] == vid) c++; + + h_colors(vid) = c; + } + Kokkos::deep_copy(vertex_colors_, h_colors); + delete[] forbidden; + } // resolveConflicts (end) + + + // ------------------------------------------------------ + // Functors: Helpers + // ------------------------------------------------------ + + + // pretty-print a 1D View with label + template + void prettyPrint1DView(kokkos_view_t &view, const char *label, const size_t max_entries = 500) const + { + int max_per_line = 20; + int line_count = 1; + std::cout << label << " = [ \n\t"; + for(size_t i = 0; i < view.extent(0); i++) + { + std::cout << std::setw(5) << view(i) << " "; + if(line_count >= max_per_line) + { + std::cout << std::endl << "\t"; + line_count = 0; + } + line_count++; + if(i >= max_entries - 1) { - _colors(vid) = offset + c; - foundColor = true; - break; + std::cout << ""; + break; } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // for offset... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColor (end) - - - - template - struct functorFindConflicts_Atomic - { - nnz_lno_t nv; // num verts - const_lno_row_view_t _idx; - adj_view_t _adj; - const_clno_row_view_t _t_idx; - const_clno_nnz_view_t _t_adj; - color_view_type _colors; - nnz_lno_temp_work_view_t _vertexList; - nnz_lno_temp_work_view_t _recolorList; - single_dim_index_view_type _recolorListLength; - - - functorFindConflicts_Atomic(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_temp_work_view_t recolorList, - single_dim_index_view_type recolorListLength) - : nv (nv_), - _idx(xadj_), - _adj(adj_), - _t_idx(t_xadj_), - _t_adj(t_adj_), - _colors(colors), - _vertexList(vertexList), - _recolorList(recolorList), - _recolorListLength(recolorListLength) - { } - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_, nnz_lno_t& numConflicts) const + } + if(line_count > 1) + std::cout << std::endl; + std::cout << "\t ]" << std::endl; + } // prettyPrint1DView (end) + + + + // ------------------------------------------------------ + // Functors: Distance-2 Graph Coloring + // ------------------------------------------------------ + + public: + /** + * Functor to init a list sequentialy, that is list[i] = i + */ + template + struct functorInitList { - typedef typename std::remove_reference< decltype( _recolorListLength() ) >::type atomic_incr_type; - nnz_lno_t vid = _vertexList(vid_); - color_t my_color = _colors(vid); + view_type _vertexList; + functorInitList(view_type vertexList) : _vertexList(vertexList) {} - size_type vid_1adj = _idx(vid); - size_type vid_1adj_end = _idx(vid+1); + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t i) const + { + // Natural order + _vertexList(i) = i; + } + }; // struct functorInitList (end) - for(; vid_1adj < vid_1adj_end; vid_1adj++) - { - nnz_lno_t vid_1idx = _adj(vid_1adj); - bool break_out = false; - for(size_type vid_2adj=_t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx+1); vid_2adj++) + /** + * Functor for VB algorithm speculative coloring without edge filtering. + */ + struct functorGreedyColor + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColor(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); - - if(vid == vid_2idx || vid_2idx >= nv) continue; - - if(_colors(vid_2idx) == my_color) - { - _colors(vid) = 0; // uncolor vertex - // Atomically add vertex to recolorList - const nnz_lno_t k = Kokkos::atomic_fetch_add( &_recolorListLength(), atomic_incr_type(1)); - _recolorList(k) = vid; - numConflicts += 1; - break_out = true; - break; // Can exit if vertex gets marked as a conflict. - } } - if(break_out) break; - } - } - }; // struct functorFindConflicts_Atomic (end) -}; // end class GraphColorD2 + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t vid_) const + { + // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; + nnz_lno_t vid = 0; + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + if(vid_ * _chunkSize + ichunk < _vertexListLength) + vid = _vertexList(vid_ * _chunkSize + ichunk); + else + continue; + + // Already colored this vertex. + if(_colors(vid) > 0) + { + continue; + } + + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations + // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. + // This could be as big as all the vertices in the graph if diameter(G)=2... + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + // by convention, start at 1 + if(offset == 0) + { + forbidden[0] = true; + } + + // Check neighbors, fill forbidden array. + for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) + { + nnz_lno_t vid_1idx = _adj(vid_1adj); + + for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + { + nnz_lno_t vid_2idx = _t_adj(vid_2adj); + + // Skip distance-2-self-loops + if(vid_2idx == vid || vid_2idx >= nv) + { + continue; + } + + color_t c = _colors(vid_2idx); + + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + forbidden[c - offset] = true; + } + } + } + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // for offset... + } // for ichunk... + } // operator() (end) + }; // struct functorGreedyColor (end) + + + + template + struct functorFindConflicts_Atomic + { + nnz_lno_t nv; // num verts + const_lno_row_view_t _idx; + adj_view_t _adj; + const_clno_row_view_t _t_idx; + const_clno_nnz_view_t _t_adj; + color_view_type _colors; + nnz_lno_temp_work_view_t _vertexList; + nnz_lno_temp_work_view_t _recolorList; + single_dim_index_view_type _recolorListLength; + + + functorFindConflicts_Atomic(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_temp_work_view_t recolorList, + single_dim_index_view_type recolorListLength) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _recolorList(recolorList), + _recolorListLength(recolorListLength) + { + } + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t vid_, nnz_lno_t &numConflicts) const + { + typedef typename std::remove_reference::type atomic_incr_type; + nnz_lno_t vid = _vertexList(vid_); + color_t my_color = _colors(vid); + + size_type vid_1adj = _idx(vid); + size_type vid_1adj_end = _idx(vid + 1); + + for(; vid_1adj < vid_1adj_end; vid_1adj++) + { + nnz_lno_t vid_1idx = _adj(vid_1adj); + + bool break_out = false; + + for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + { + nnz_lno_t vid_2idx = _t_adj(vid_2adj); + + if(vid == vid_2idx || vid_2idx >= nv) + continue; + + if(_colors(vid_2idx) == my_color) + { + _colors(vid) = 0; // uncolor vertex + // Atomically add vertex to recolorList + const nnz_lno_t k = Kokkos::atomic_fetch_add(&_recolorListLength(), atomic_incr_type(1)); + _recolorList(k) = vid; + numConflicts += 1; + break_out = true; + break; // Can exit if vertex gets marked as a conflict. + } + } + if(break_out) + break; + } + } + }; // struct functorFindConflicts_Atomic (end) + + +}; // end class GraphColorD2 -} // end Impl namespace -} // end KokkosGraph namespace +} // namespace Impl +} // namespace KokkosGraph -#endif // _KOKKOSCOLORINGD2IMP_HPP +#endif // _KOKKOSCOLORINGD2IMP_HPP From 2cb3d5af5b9494b8de21d124baea8af44da5e24a Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 31 May 2018 09:01:47 -0600 Subject: [PATCH 009/190] D2Color: Refactor Changing name of execution method in Distance-2 coloring classes to just be execute since MatrixSquared and the Direct method are in separate classes anyhow. It's redundant to have the method that runs the algorithm be: - `GraphColorD2_MatrixSquared::color_graph_d2_matrix_squared()` - `GraphColorD2::color_graph_d2()` Since we know already what we're executing because of the classtype. Split the Distance-2 Matrix-Squared version into a separate impl file in `src/graph/impl`. The new file is `src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp`. Renamed KokkosGraph files in `src/graph` to be more consistent with the files in `src/graph/impl` in naming convention and to reduce confusion due to naming conflict in `perf_test/graph` - `KokkosGraph_graph_color.hpp` --> `KokkosGraph_GraphColor.hpp` - Aligns with `impl/KokkosGraph_GraphColor_impl.hpp` - `KokkosGraph_graph_color_d2.hpp` --> `KokkosGraph_Distance2Color.hpp` - Aligns with `impl/KokkosGraph_Distance2Color*_impl.hpp` TODO: - Rename the Direct method class to something that is more in-line with whether or not it's a vertex-based method, edge based method, etc. --- perf_test/graph/KokkosGraph_color.cpp | 2 +- perf_test/graph/KokkosGraph_color_d2.cpp | 90 ++++---- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 11 +- ..._d2.hpp => KokkosGraph_Distance2Color.hpp} | 7 +- ...h_color.hpp => KokkosGraph_GraphColor.hpp} | 0 src/graph/KokkosGraph_GraphColorHandle.hpp | 5 +- ...raph_Distance2Color_MatrixSquared_impl.hpp | 208 ++++++++++++++++++ .../impl/KokkosGraph_Distance2Color_impl.hpp | 139 +----------- 8 files changed, 268 insertions(+), 194 deletions(-) rename src/graph/{KokkosGraph_graph_color_d2.hpp => KokkosGraph_Distance2Color.hpp} (96%) rename src/graph/{KokkosGraph_graph_color.hpp => KokkosGraph_GraphColor.hpp} (100%) create mode 100644 src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index 830a2f4e19..3b0d3dc7f0 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -49,10 +49,10 @@ #include // std::shuffle #include -#include "KokkosGraph_graph_color.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_MyCRSMatrix.hpp" #include "KokkosKernels_TestParameters.hpp" +#include "KokkosGraph_GraphColor.hpp" diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index f37bd25609..3d0f2bbc6c 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -53,7 +53,7 @@ //// Kokkos //#include "KokkosKernels_config.h" //#include "KokkosGraph_Distance2Color.hpp" -#include "KokkosGraph_graph_color_d2.hpp" +#include "KokkosGraph_Distance2Color.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_MyCRSMatrix.hpp" @@ -88,8 +88,8 @@ typedef int64_t kk_lno_t; void print_options(std::ostream& os, const char* app_name, unsigned int indent=0) { std::string spaces(indent, ' '); - os << "Usage:" << std::endl - << spaces << " " << app_name << " [parameters]" << std::endl + os << "Usage:" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl << std::endl << spaces << "Parameters:" << std::endl << spaces << " Parallelism (select one of the following):" << std::endl @@ -98,7 +98,7 @@ void print_options(std::ostream& os, const char* app_name, unsigned int indent=0 << spaces << " openmp Use OpenMP with N threads." << std::endl << spaces << " cuda Use CUDA" << std::endl << std::endl - << spaces << " Required Parameters:" << std::endl + << spaces << " Required Parameters:" << std::endl << spaces << " amtx Input file in Matrix Market format (.mtx)." << std::endl << std::endl << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl @@ -122,57 +122,57 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char bool got_required_param_amtx=false; bool got_required_param_algorithm=false; - for(int i = 1; i < argc; ++i) + for(int i = 1; i < argc; ++i) { - if ( 0 == strcasecmp( argv[i] , "threads" ) ) + if ( 0 == strcasecmp( argv[i] , "threads" ) ) { params.use_threads = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "serial" ) ) + else if ( 0 == strcasecmp( argv[i] , "serial" ) ) { params.use_serial = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "openmp" ) ) + else if ( 0 == strcasecmp( argv[i] , "openmp" ) ) { params.use_openmp = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "cuda" ) ) + else if ( 0 == strcasecmp( argv[i] , "cuda" ) ) { params.use_cuda = 1; } - else if ( 0 == strcasecmp( argv[i] , "repeat" ) ) + else if ( 0 == strcasecmp( argv[i] , "repeat" ) ) { params.repeat = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "chunksize" ) ) + else if ( 0 == strcasecmp( argv[i] , "chunksize" ) ) { params.chunk_size = atoi( argv[++i] ) ; } - else if ( 0 == strcasecmp( argv[i] , "teamsize" ) ) + else if ( 0 == strcasecmp( argv[i] , "teamsize" ) ) { params.team_size = atoi( argv[++i] ) ; } - else if ( 0 == strcasecmp( argv[i] , "vectorsize" ) ) + else if ( 0 == strcasecmp( argv[i] , "vectorsize" ) ) { params.vector_size = atoi( argv[++i] ) ; } - else if ( 0 == strcasecmp( argv[i] , "amtx" ) ) + else if ( 0 == strcasecmp( argv[i] , "amtx" ) ) { got_required_param_amtx = true; params.a_mtx_bin_file = argv[++i]; } - else if ( 0 == strcasecmp( argv[i] , "dynamic" ) ) + else if ( 0 == strcasecmp( argv[i] , "dynamic" ) ) { params.use_dynamic_scheduling = 1; } - else if ( 0 == strcasecmp( argv[i] , "verbose" ) ) + else if ( 0 == strcasecmp( argv[i] , "verbose" ) ) { params.verbose = 1; } - else if ( 0 == strcasecmp( argv[i] , "algorithm" ) ) + else if ( 0 == strcasecmp( argv[i] , "algorithm" ) ) { ++i; - if ( 0 == strcasecmp( argv[i] , "COLORING_D2_MATRIX_SQUARED" ) ) + if ( 0 == strcasecmp( argv[i] , "COLORING_D2_MATRIX_SQUARED" ) ) { params.algorithm = 1; got_required_param_algorithm = true; @@ -182,7 +182,7 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char params.algorithm = 2; got_required_param_algorithm = true; } - else + else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; print_options(std::cout, argv[0]); @@ -194,7 +194,7 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char print_options(std::cout, argv[0]); return 1; } - else + else { std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; print_options(std::cout, argv[0]); @@ -239,7 +239,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) int team_size = params.team_size; int use_dynamic_scheduling = params.use_dynamic_scheduling; int verbose = params.verbose; - + //char spgemm_step = params.spgemm_step; int vector_size = params.vector_size; @@ -250,7 +250,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) typedef typename lno_nnz_view_t::non_const_value_type lno_t; typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; - + // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' @@ -277,7 +277,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) double total_time = 0.0; size_t total_colors = 0; size_t total_phases = 0; - + std::string label_algorithm; for (int i = 0; i < repeat; ++i) @@ -305,7 +305,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Time : " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; - std::cout << "\t"; + std::cout << "\t"; KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; @@ -388,7 +388,7 @@ void run_multi_mem_experiment(Parameters params) a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); } - else + else { slow_crstmat_t a_slow_crsmat; a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); @@ -409,7 +409,7 @@ void run_multi_mem_experiment(Parameters params) (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); } - else + else { /* c_fast_crsgraph = */ KokkosKernels::Experiment::run_experiment @@ -418,7 +418,7 @@ void run_multi_mem_experiment(Parameters params) } } - else + else { //C is in slow memory. if (params.work_mem_space == 1) @@ -428,7 +428,7 @@ void run_multi_mem_experiment(Parameters params) (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); } - else + else { /*c_slow_crsgraph =*/ KokkosKernels::Experiment::run_experiment @@ -437,7 +437,7 @@ void run_multi_mem_experiment(Parameters params) } } } - else + else { //B is in slow memory if (params.c_mem_space == 1) @@ -449,7 +449,7 @@ void run_multi_mem_experiment(Parameters params) (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); } - else + else { /* c_fast_crsgraph = */ KokkosKernels::Experiment::run_experiment @@ -458,7 +458,7 @@ void run_multi_mem_experiment(Parameters params) } } - else + else { //C is in slow memory. if (params.work_mem_space == 1) @@ -468,7 +468,7 @@ void run_multi_mem_experiment(Parameters params) (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); } - else + else { /*c_slow_crsgraph =*/ KokkosKernels::Experiment::run_experiment @@ -479,7 +479,7 @@ void run_multi_mem_experiment(Parameters params) } } - else + else { //A is in slow memory if (params.b_mem_space == 1) @@ -493,7 +493,7 @@ void run_multi_mem_experiment(Parameters params) (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); } - else + else { /* c_fast_crsgraph = */ KokkosKernels::Experiment::run_experiment @@ -501,7 +501,7 @@ void run_multi_mem_experiment(Parameters params) (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); } } - else + else { //C is in slow memory. if (params.work_mem_space == 1) @@ -511,7 +511,7 @@ void run_multi_mem_experiment(Parameters params) (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); } - else + else { /*c_slow_crsgraph =*/ KokkosKernels::Experiment::run_experiment @@ -520,7 +520,7 @@ void run_multi_mem_experiment(Parameters params) } } } - else + else { //B is in slow memory if (params.c_mem_space == 1) @@ -532,7 +532,7 @@ void run_multi_mem_experiment(Parameters params) (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); } - else + else { /* c_fast_crsgraph = */ KokkosKernels::Experiment::run_experiment @@ -540,17 +540,17 @@ void run_multi_mem_experiment(Parameters params) (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); } } - else + else { //C is in slow memory. - if (params.work_mem_space == 1) + if (params.work_mem_space == 1) { /*c_slow_crsgraph =*/ KokkosKernels::Experiment::run_experiment (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); } - else + else { /*c_slow_crsgraph =*/ KokkosKernels::Experiment::run_experiment @@ -582,7 +582,7 @@ int main (int argc, char ** argv) return 0; } - std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl + std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl << "Sizeof(size_type): " << sizeof(kk_size_type) << std::endl; const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads @@ -591,7 +591,7 @@ int main (int argc, char ** argv) Kokkos::print_configuration(std::cout); #if defined( KOKKOS_ENABLE_OPENMP ) - if (params.use_openmp) + if (params.use_openmp) { #ifdef KOKKOSKERNELS_MULTI_MEM KokkosKernels::Experiment::run_multi_mem_experiment @@ -605,7 +605,7 @@ int main (int argc, char ** argv) #if defined( KOKKOS_ENABLE_CUDA ) - if (params.use_cuda) + if (params.use_cuda) { #ifdef KOKKOSKERNELS_MULTI_MEM KokkosKernels::Experiment::run_multi_mem_experiment @@ -619,7 +619,7 @@ int main (int argc, char ** argv) #if defined( KOKKOS_ENABLE_SERIAL ) - if (params.use_serial) + if (params.use_serial) { #ifdef KOKKOSKERNELS_MULTI_MEM KokkosKernels::Experiment::run_multi_mem_experiment diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 598c288974..37b4a376aa 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -57,7 +57,7 @@ #include #include #include -#include +#include using namespace KokkosGraph; @@ -227,6 +227,7 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * return 0; } + namespace KokkosKernels { namespace Experiment { @@ -259,13 +260,12 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' - std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; KernelHandle kh; - kh.set_team_work_size(chunk_size); + kh.set_team_work_size(chunk_size); // WCMCLEN - Team Policy kh.set_shmem_size(shmemsize); - kh.set_suggested_team_size(team_size); + kh.set_suggested_team_size(team_size); // WCMCLEN - Team Policy kh.set_suggested_vector_size(vector_size); if(use_dynamic_scheduling) @@ -291,7 +291,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) switch(algorithm) { case 1: - // kh.create_graph_coloring_handle(COLORING_SPGEMM); kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; break; @@ -638,7 +637,7 @@ int main(int argc, char *argv[]) double time = 1.0 * (end.tv_sec - begin.tv_sec) + 1.0e-6 * (end.tv_usec - begin.tv_usec); std::cout << "Time: " << time << std::endl; - */ + */ Kokkos::finalize(); diff --git a/src/graph/KokkosGraph_graph_color_d2.hpp b/src/graph/KokkosGraph_Distance2Color.hpp similarity index 96% rename from src/graph/KokkosGraph_graph_color_d2.hpp rename to src/graph/KokkosGraph_Distance2Color.hpp index 490c40d5eb..32ab5637f3 100644 --- a/src/graph/KokkosGraph_graph_color_d2.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -44,6 +44,7 @@ #define _KOKKOS_GRAPH_COLORD2_HPP #include "KokkosGraph_Distance2Color_impl.hpp" +#include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" #include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" @@ -61,7 +62,7 @@ void graph_color_d2(KernelHandle *handle, lno_row_view_t_ row_map, lno_nnz_view_t_ row_entries, // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, + lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries) { Kokkos::Impl::Timer timer; @@ -87,7 +88,7 @@ void graph_color_d2(KernelHandle *handle, { Impl::GraphColorD2_MatrixSquared gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.color_graph_d2_matrix_squared(); + gc.execute(); break; } @@ -95,7 +96,7 @@ void graph_color_d2(KernelHandle *handle, { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.color_graph_d2(); + gc.execute(); break; } diff --git a/src/graph/KokkosGraph_graph_color.hpp b/src/graph/KokkosGraph_GraphColor.hpp similarity index 100% rename from src/graph/KokkosGraph_graph_color.hpp rename to src/graph/KokkosGraph_GraphColor.hpp diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 8239c516b3..9dbf4ce505 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -66,7 +66,7 @@ enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; enum ColoringType {Distance1, Distance2}; -template class GraphColoringHandle @@ -173,7 +173,8 @@ class GraphColoringHandle overall_coloring_time(0), coloring_time(0), num_phases(0), size_of_edge_list(0), lower_triangle_src(), lower_triangle_dst(), - vertex_colors(), is_coloring_called_before(false), num_colors(0){ + vertex_colors(), is_coloring_called_before(false), num_colors(0) + { this->choose_default_algorithm(); this->set_defaults(this->coloring_algorithm_type); } diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp new file mode 100644 index 0000000000..599d805d9f --- /dev/null +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -0,0 +1,208 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#include +#include + +#include +#include +#include +#include +#include + +#include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_graph_color.hpp" +#include "KokkosKernels_Handle.hpp" + +#ifndef _KOKKOSCOLORINGD2MATRIXSQUAREDIMP_HPP +#define _KOKKOSCOLORINGD2MATRIXSQUAREDIMP_HPP + + +namespace KokkosGraph { + +namespace Impl { + +#define VB_D2_COLORING_FORBIDDEN_SIZE 64 +// #define VB_D2_COLORING_FORBIDDEN_SIZE 20000 + + + +/*! \brief Base class for graph coloring purposes. + * Each color represents the set of the vertices that are independent, + * e.g. no vertex having same color shares an edge. + * General aim is to find the minimum number of colors, minimum number of independent sets. + */ +template +class GraphColorD2_MatrixSquared +{ + public: + typedef lno_row_view_t_ in_lno_row_view_t; + typedef lno_nnz_view_t_ in_lno_nnz_view_t; + + typedef typename HandleType::GraphColoringHandleType::color_t color_t; + typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; + + typedef typename HandleType::size_type size_type; + typedef typename HandleType::nnz_lno_t nnz_lno_t; + + typedef typename HandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; + typedef typename HandleType::const_size_type const_size_type; + + typedef typename lno_row_view_t_::device_type row_lno_view_device_t; + typedef typename lno_row_view_t_::const_type const_lno_row_view_t; + typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; + typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; + + typedef typename clno_row_view_t_::const_type const_clno_row_view_t; + typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; + typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; + + typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; + typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; + typedef typename HandleType::nnz_lno_persistent_work_view_t nnz_lno_persistent_work_view_t; + + typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename Kokkos::View single_dim_index_view_type; + + typedef Kokkos::RangePolicy my_exec_space; + + + protected: + nnz_lno_t nr; // num_rows (# verts) + nnz_lno_t nc; // num cols + size_type ne; // # edges + const_lno_row_view_t xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) + const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap + const_clno_nnz_view_t t_adj; // entries, transpose of entries + nnz_lno_t nv; // num vertices + HandleType *cp; // the handle. + + public: + /** + * \brief GraphColor constructor. + * + * \param nv_: number of vertices in the graph + * \param ne_: number of edges in the graph + * \param row_map: the xadj array of the graph. Its size is nv_ +1 + * \param entries: adjacency array of the graph. Its size is ne_ + * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, + * including parameters. + */ + GraphColorD2_MatrixSquared(nnz_lno_t nr_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, + const_clno_row_view_t t_row_map, + const_clno_nnz_view_t t_entries, + HandleType *handle) + : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle) + { + } + + + /** \brief GraphColor destructor. + */ + virtual ~GraphColorD2_MatrixSquared() {} + + + /** + * \brief Function to color the vertices of the graphs. This is the base class, + * therefore, it only performs sequential coloring on the host device, ignoring the execution space. + * + * \param colors is the output array corresponding the color of each vertex.Size is this->nv. + * Attn: Color array must be nonnegative numbers. If there is no initial colors, + * it should be all initialized with zeros. Any positive value in the given array, will make the + * algorithm to assume that the color is fixed for the corresponding vertex. + * \param num_phases: The number of iterations (phases) that algorithm takes to converge. + */ + virtual void execute() + { + std::string algName = "SPGEMM_KK_MEMSPEED"; + cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); + + size_type_temp_work_view_t cRowptrs("cRowptrs", nr + 1); + + // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) + KokkosSparse::Experimental::spgemm_symbolic(cp, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); + + // Get num nz in C + auto Cnnz = cp->get_spgemm_handle()->get_c_nnz(); + + // Must create placeholder value views for A and C (values are meaningless) + // Said above that the scalar view type is the same as the colinds view type + scalar_temp_work_view_t aFakeValues("A/B placeholder values (meaningless)", adj.size()); + + // Allocate C entries array, and placeholder values + nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); + scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + + // Run the numeric kernel + KokkosSparse::Experimental::spgemm_numeric( + cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); + + // done with spgemm + cp->destroy_spgemm_handle(); + + // Now run distance-1 graph coloring on C + // Use LocalOrdinal for storing colors + KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); + + // extract the colors + // auto coloringHandle = cp->get_graph_coloring_handle(); + // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); + + // clean up coloring handle + // cp->destroy_graph_coloring_handle(); + } + +}; // GraphColorD2_MatrixSquared (end) + + + +} // namespace Impl +} // namespace KokkosGraph + + +#endif // _KOKKOSCOLORINGD2MATRIXSQUAREDIMP_HPP diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 0bbe0ce522..4ec472a5c2 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -57,147 +57,12 @@ #define _KOKKOSCOLORINGD2IMP_HPP -// #define EBCOLORING_HIGHER_QUALITY //suggested -// namespace KokkosGraph { namespace Impl { #define VB_D2_COLORING_FORBIDDEN_SIZE 64 // #define VB_D2_COLORING_FORBIDDEN_SIZE 20000 -// #define VBBIT_COLORING_FORBIDDEN_SIZE 64 - - - -/*! \brief Base class for graph coloring purposes. - * Each color represents the set of the vertices that are independent, - * e.g. no vertex having same color shares an edge. - * General aim is to find the minimum number of colors, minimum number of independent sets. - */ -template -class GraphColorD2_MatrixSquared -{ - public: - typedef lno_row_view_t_ in_lno_row_view_t; - typedef lno_nnz_view_t_ in_lno_nnz_view_t; - - typedef typename HandleType::GraphColoringHandleType::color_t color_t; - typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; - - typedef typename HandleType::size_type size_type; - typedef typename HandleType::nnz_lno_t nnz_lno_t; - - typedef typename HandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::const_size_type const_size_type; - - typedef typename lno_row_view_t_::device_type row_lno_view_device_t; - typedef typename lno_row_view_t_::const_type const_lno_row_view_t; - typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; - typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - - typedef typename clno_row_view_t_::const_type const_clno_row_view_t; - typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; - typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - - typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; - typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; - typedef typename HandleType::nnz_lno_persistent_work_view_t nnz_lno_persistent_work_view_t; - - typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; - typedef typename Kokkos::View single_dim_index_view_type; - - typedef Kokkos::RangePolicy my_exec_space; - - - protected: - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) - const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap - const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - HandleType *cp; // the handle. - - public: - /** - * \brief GraphColor constructor. - * \param nv_: number of vertices in the graph - * \param ne_: number of edges in the graph - * \param row_map: the xadj array of the graph. Its size is nv_ +1 - * \param entries: adjacency array of the graph. Its size is ne_ - * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, - * including parameters. - */ - GraphColorD2_MatrixSquared(nnz_lno_t nr_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType *handle) - : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle) - { - } - - - /** \brief GraphColor destructor. - */ - virtual ~GraphColorD2_MatrixSquared() {} - - - /** \brief Function to color the vertices of the graphs. This is the base class, - * therefore, it only performs sequential coloring on the host device, ignoring the execution space. - * \param colors is the output array corresponding the color of each vertex.Size is this->nv. - * Attn: Color array must be nonnegative numbers. If there is no initial colors, - * it should be all initialized with zeros. Any positive value in the given array, will make the - * algorithm to assume that the color is fixed for the corresponding vertex. - * \param num_phases: The number of iterations (phases) that algorithm takes to converge. - */ - virtual void color_graph_d2_matrix_squared() - { - std::string algName = "SPGEMM_KK_MEMSPEED"; - cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); - - size_type_temp_work_view_t cRowptrs("cRowptrs", nr + 1); - - // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) - KokkosSparse::Experimental::spgemm_symbolic(cp, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); - - // Get num nz in C - auto Cnnz = cp->get_spgemm_handle()->get_c_nnz(); - - // Must create placeholder value views for A and C (values are meaningless) - // Said above that the scalar view type is the same as the colinds view type - scalar_temp_work_view_t aFakeValues("A/B placeholder values (meaningless)", adj.size()); - - // Allocate C entries array, and placeholder values - nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); - scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); - - // Run the numeric kernel - KokkosSparse::Experimental::spgemm_numeric( - cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); - - // done with spgemm - cp->destroy_spgemm_handle(); - - // Now run distance-1 graph coloring on C - // Use LocalOrdinal for storing colors - KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); - - // extract the colors - // auto coloringHandle = cp->get_graph_coloring_handle(); - // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); - - // clean up coloring handle - // cp->destroy_graph_coloring_handle(); - } - -}; // GraphColorD2_MatrixSquared (end) @@ -298,10 +163,10 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::color_graph_d2() + // GraphColorD2::execute() // // ----------------------------------------------------------------- - virtual void color_graph_d2() + virtual void execute() { color_view_type colors_out("Graph Colors", this->nv); From 529ac1425fbb26122347dce158e920569df3197f Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 1 Jun 2018 14:45:30 -0600 Subject: [PATCH 010/190] D2 Color: Enabling cumulative timers for the phases of computation --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 82 ++++++++++++++----- src/graph/KokkosGraph_GraphColorHandle.hpp | 17 ++++ .../impl/KokkosGraph_Distance2Color_impl.hpp | 58 +++++++------ 3 files changed, 111 insertions(+), 46 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 37b4a376aa..3d1153ba28 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -43,6 +43,9 @@ // EXERCISE 1 Goal: // Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. +#include +#include + #include #include @@ -116,7 +119,7 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << spaces << " repeat Set number of test repetitions (Default: 6) " << std::endl << spaces << " teamsize Set the team size." << std::endl << spaces << " vectorsize Set the vector size." << std::endl - << spaces << " verbose Enable verbose mode (print timing + extra information" << std::endl + << spaces << " verbose Enable verbose mode (record and print timing + extra information)" << std::endl << spaces << " help Print out command line help." << std::endl << spaces << " " << std::endl; } @@ -279,12 +282,16 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) } // accumulators for average stats - double total_time = 0.0; - size_t total_colors = 0; - size_t total_phases = 0; + double total_time = 0.0; + double total_time_color_greedy = 0.0; + double total_time_find_conflicts = 0.0; + double total_time_resolve_conflicts = 0.0; + size_t total_colors = 0; + size_t total_phases = 0; std::string label_algorithm; + // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { @@ -313,50 +320,87 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; - total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); + total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); total_colors += kh.get_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_graph_coloring_handle()->get_num_phases(); + total_time_color_greedy += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); + total_time_find_conflicts += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); + total_time_resolve_conflicts += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); } - double avg_time = total_time / repeat; - double avg_colors = total_colors / (double)repeat; - double avg_phases = total_phases / (double)repeat; + double avg_time = total_time / repeat; + double avg_time_color_greedy = total_time_color_greedy / repeat; + double avg_time_find_conflicts = total_time_find_conflicts / repeat; + double avg_time_resolve_conflicts = total_time_resolve_conflicts / repeat; + double avg_colors = total_colors / (double)repeat; + double avg_phases = total_phases / (double)repeat; std::string a_mtx_bin_file = params.a_mtx_bin_file; a_mtx_bin_file = a_mtx_bin_file.substr(a_mtx_bin_file.find_last_of("/\\") + 1); + + int result; + char hostname[100]; + char username[100]; + + result = gethostname(hostname, 100); + if(result) + { + perror("gethostname"); + } + + result = getlogin_r(username, 100); + if(result) + { + perror("getlogin_r"); + } + + std::cout << "Summary:" << std::endl - << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl - << " Filename : " << a_mtx_bin_file << std::endl - << " Num Verts : " << crsGraph.numRows() << std::endl - << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl - << " Concurrency: " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl - << " Algorithm : " << label_algorithm << std::endl - << " Avg Time : " << avg_time << std::endl - << " Avg colors : " << avg_colors << std::endl - << " Avg Phases : " << avg_phases << std::endl + << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl + << " Filename : " << a_mtx_bin_file << std::endl + << " Num Verts : " << crsGraph.numRows() << std::endl + << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl + << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl + << " Algorithm : " << label_algorithm << std::endl + << " Avg Time : " << avg_time << std::endl + << " Avg Time CG : " << avg_time_color_greedy << std::endl + << " Avg Time FC : " << avg_time_find_conflicts << std::endl + << " Avg Time RC : " << avg_time_resolve_conflicts << std::endl + << " Avg colors : " << avg_colors << std::endl + << " Avg Phases : " << avg_phases << std::endl << std::endl; std::cout << "CSVHDR" << "," << "Filename" + << "," << "Host" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" << "," << "Concurrency" << "," << "Algorithm" - << "," << "Avg Time" + << "," << "Repetitions" + << "," << "Total Time" + << "," << "Total Time CG" + << "," << "Total Time FC" + << "," << "Total Time RC" << "," << "Avg Colors" << "," << "Avg Num Phases" << std::endl; std::cout << "CSVDATA" << "," << a_mtx_bin_file + << "," << hostname << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() << "," << Kokkos::DefaultExecutionSpace::concurrency() << "," << label_algorithm - << "," << avg_time + << "," << repeat + << "," << total_time + << "," << total_time_color_greedy + << "," << total_time_find_conflicts + << "," << total_time_resolve_conflicts << "," << avg_colors << "," << avg_phases << std::endl; diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 9dbf4ce505..de7b927019 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -139,7 +139,12 @@ class GraphColoringHandle //STATISTICS double overall_coloring_time; //the overall time that it took to color the graph. In the case of the iterative calls. + double overall_coloring_time_phase1; // + double overall_coloring_time_phase2; // Some detailed timer accumulators for (generic) internal phases + double overall_coloring_time_phase3; // + double overall_coloring_time_phase4; // double coloring_time; //the time that it took to color the graph + int num_phases; // @@ -171,6 +176,10 @@ class GraphColoringHandle vb_chunk_size(8), max_number_of_iterations(200), eb_num_initial_colors(1), overall_coloring_time(0), + overall_coloring_time_phase1(0), + overall_coloring_time_phase2(0), + overall_coloring_time_phase3(0), + overall_coloring_time_phase4(0), coloring_time(0), num_phases(0), size_of_edge_list(0), lower_triangle_src(), lower_triangle_dst(), vertex_colors(), is_coloring_called_before(false), num_colors(0) @@ -643,6 +652,10 @@ class GraphColoringHandle int get_eb_num_initial_colors() const{return this->eb_num_initial_colors;} double get_overall_coloring_time() const { return this->overall_coloring_time;} + double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } + double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } + double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } + double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } double get_coloring_time() const { return this->coloring_time;} int get_num_phases() const { return this->num_phases;} color_view_t get_vertex_colors() const {return this->vertex_colors;} @@ -659,6 +672,10 @@ class GraphColoringHandle void set_max_number_of_iterations(const int &max_phases){this->max_number_of_iterations = max_phases;} void set_eb_num_initial_colors(const int &num_initial_colors){this->eb_num_initial_colors = num_initial_colors;} void add_to_overall_coloring_time(const double &coloring_time_){this->overall_coloring_time += coloring_time_;} + void add_to_overall_coloring_time_phase1(const double &coloring_time_){this->overall_coloring_time_phase1 += coloring_time_;} + void add_to_overall_coloring_time_phase2(const double &coloring_time_){this->overall_coloring_time_phase2 += coloring_time_;} + void add_to_overall_coloring_time_phase3(const double &coloring_time_){this->overall_coloring_time_phase3 += coloring_time_;} + void add_to_overall_coloring_time_phase4(const double &coloring_time_){this->overall_coloring_time_phase4 += coloring_time_;} void set_coloring_time(const double &coloring_time_){this->coloring_time = coloring_time_;} void set_num_phases(const double &num_phases_){this->num_phases = num_phases_;} void set_vertex_colors( const color_view_t vertex_colors_){ diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 4ec472a5c2..9b8eda1adb 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -66,7 +66,8 @@ namespace Impl { -/*! \brief Base class for graph coloring purposes. +/*! + * \brief Base class for graph coloring purposes. * Each color represents the set of the vertices that are independent, * e.g. no vertex having same color shares an edge. * General aim is to find the minimum number of colors, minimum number of independent sets. @@ -117,7 +118,7 @@ class GraphColorD2 const_clno_nnz_view_t t_adj; // entries, transpose of entries nnz_lno_t nv; // num vertices - typename HandleType::GraphColoringHandleType *cp; // pointer to the graph coloring handle + typename HandleType::GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle private: int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs @@ -146,17 +147,18 @@ class GraphColorD2 const_clno_nnz_view_t t_entries, HandleType *handle) : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), - cp(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), + gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1), _serialConflictResolution(false), _use_color_set(0), _ticToc(handle->get_verbose()) { // std::cout << ">>> WCMCLEN GraphColorD2() (KokkosGraph_Distance2Color_impl.hpp)" << std::endl - // << ">>> WCMCLEN : coloring_algo_type = " << handle->get_coloring_algo_type() << std::endl - // << ">>> WCMCLEN : conflict_list_type = " << handle->get_conflict_list_type() << std::endl; + // << ">>> WCMCLEN : coloring_algo_type = " << handle->get_coloring_algo_type() << std::endl + // << ">>> WCMCLEN : conflict_list_type = " << handle->get_conflict_list_type() << std::endl; } - /** \brief GraphColor destructor. + /** + * \brief GraphColor destructor. */ virtual ~GraphColorD2() {} @@ -168,16 +170,14 @@ class GraphColorD2 // ----------------------------------------------------------------- virtual void execute() { - color_view_type colors_out("Graph Colors", this->nv); // Data: - // cp = graph coloring handle - // nr = num_rows (scalar) - // nc = num_cols (scalar) - // xadj = row_map (view 1 dimension - [num_verts+1] - entries index into adj ) - // adj = entries (view 1 dimension - [num_edges] - adjacency list ) - + // gc_handle = graph coloring handle + // nr = num_rows (scalar) + // nc = num_cols (scalar) + // xadj = row_map (view 1 dimension - [num_verts+1] - entries index into adj ) + // adj = entries (view 1 dimension - [num_edges] - adjacency list ) if(this->_ticToc) { std::cout << "\tcolor_graph_d2 params:" << std::endl @@ -219,7 +219,8 @@ class GraphColorD2 nnz_lno_t numUncolored = this->nv; nnz_lno_t current_vertexListLength = this->nv; - double t, total = 0.0; + double time; + double total_time = 0.0; Kokkos::Impl::Timer timer; int iter = 0; @@ -232,10 +233,11 @@ class GraphColorD2 if(this->_ticToc) { - t = timer.seconds(); - total += t; - std::cout << "\tTime speculative greedy phase " << std::setw(-2) << iter << " : " << t << std::endl; + time = timer.seconds(); + total_time += time; + std::cout << "\tTime speculative greedy phase " << std::setw(-2) << iter << " : " << time << std::endl; timer.reset(); + gc_handle->add_to_overall_coloring_time_phase1(time); } // prettyPrint1DView(colors_out, ">>> WCMCLEN colors_out", 100); @@ -260,10 +262,11 @@ class GraphColorD2 if(_ticToc) { - t = timer.seconds(); - total += t; - std::cout << "\tTime conflict detection " << std::setw(-2) << iter << " : " << t << std::endl; + time = timer.seconds(); + total_time += time; + std::cout << "\tTime conflict detection " << std::setw(-2) << iter << " : " << time << std::endl; timer.reset(); + gc_handle->add_to_overall_coloring_time_phase2(time); } // If conflictList is used and we need to swap the work arrays @@ -293,14 +296,15 @@ class GraphColorD2 if(_ticToc) { - t = timer.seconds(); - total += t; - std::cout << "\tTime serial conflict resolution : " << t << std::endl; + time = timer.seconds(); + total_time += time; + std::cout << "\tTime serial conflict resolution : " << time << std::endl; + gc_handle->add_to_overall_coloring_time_phase3(time); } // Save out the number of phases and vertex colors - this->cp->set_vertex_colors(colors_out); - this->cp->set_num_phases((double)iter); + this->gc_handle->set_vertex_colors(colors_out); + this->gc_handle->set_num_phases((double)iter); } // color_graph_d2 (end) @@ -613,7 +617,7 @@ class GraphColorD2 // Do multiple passes if the array is too small. // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. + // but in distance-2 we'd need the total_time vertices at distance-2 which we don't easily have aprioi. // This could be as big as all the vertices in the graph if diameter(G)=2... // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). color_t offset = 0; @@ -666,7 +670,7 @@ class GraphColorD2 } // for offset... } // for ichunk... } // operator() (end) - }; // struct functorGreedyColor (end) + }; // struct functorGreedyColor (end) From 59876780fd76de515cf637735fc01e581b236123 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 5 Jun 2018 15:24:52 -0600 Subject: [PATCH 011/190] sharing code for Nathan --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 9b8eda1adb..140aad799a 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -107,6 +107,9 @@ class GraphColorD2 typedef Kokkos::RangePolicy my_exec_space; + typedef Kokkos::TeamPolicy team_policy_t ; + typedef typename team_policy_t::member_type team_member_t ; + protected: nnz_lno_t nr; // num_rows (# verts) @@ -188,6 +191,8 @@ class GraphColorD2 << "\t serialConflictResolution : " << (int)this->_serialConflictResolution << std::endl << "\t chunkSize : " << this->_chunkSize << std::endl << "\t use_color_set : " << (int)this->_use_color_set << std::endl +// << "\t team_size : " << (int)gc_handle->get_suggested_team_size() << std::endl +// << "\t team_size : " << team_policy_t::team_size_max() << std::endl << "\tgraph information:" << std::endl << "\t nv : " << this->nv << std::endl << "\t ne : " << this->ne << std::endl; @@ -226,7 +231,9 @@ class GraphColorD2 int iter = 0; for(; (iter < _max_num_iterations) && (numUncolored > 0); iter++) { + // ------------------------------------------ // Do greedy color + // ------------------------------------------ this->colorGreedy(this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); MyExecSpace::fence(); @@ -242,7 +249,9 @@ class GraphColorD2 // prettyPrint1DView(colors_out, ">>> WCMCLEN colors_out", 100); + // ------------------------------------------ // Find conflicts + // ------------------------------------------ bool swap_work_arrays = true; // NOTE: swap_work_arrays can go away in this example -- was only ever // set false in the PPS code in the original D1 coloring... @@ -285,7 +294,9 @@ class GraphColorD2 } } // end for iter... - // clean up in serial + // ------------------------------------------ + // clean up in serial (resolveConflicts) + // ------------------------------------------ if(numUncolored > 0) { this->resolveConflicts( @@ -334,7 +345,11 @@ class GraphColorD2 functorGreedyColor gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); + // This one works but no team policy + //Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); + + // Experimental + Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO) , gc); // WCMCLEN - attempt } // colorGreedy (end) From 82375a9f9adfac52d59c279374728d77e43cdd31 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 5 Jun 2018 16:08:34 -0600 Subject: [PATCH 012/190] development snapshot --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 128 +++++++++--------- 1 file changed, 65 insertions(+), 63 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 140aad799a..6d85fdef84 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -349,7 +349,8 @@ class GraphColorD2 //Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); // Experimental - Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO) , gc); // WCMCLEN - attempt + //Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO) , gc); // WCMCLEN - attempt + Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, chunkSize_) , gc); // WCMCLEN - attempt } // colorGreedy (end) @@ -607,85 +608,86 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_) const + void operator()(team_member_t &thread) const { + nnz_lno_t vid_ = thread.league_rank() * thread.team_size() + thread.team_rank(); + // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; nnz_lno_t vid = 0; - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) - { + // for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) // WCMCLEN: would change to a parallel_for + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { if(vid_ * _chunkSize + ichunk < _vertexListLength) - vid = _vertexList(vid_ * _chunkSize + ichunk); - else - continue; - - // Already colored this vertex. - if(_colors(vid) > 0) { - continue; - } - - bool foundColor = false; // Have we found a valid color? + vid = _vertexList(vid_ * _chunkSize + ichunk); - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + // Already colored this vertex. + if(_colors(vid) <= 0) + { - // Do multiple passes if the array is too small. - // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total_time vertices at distance-2 which we don't easily have aprioi. - // This could be as big as all the vertices in the graph if diameter(G)=2... - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; + bool foundColor = false; // Have we found a valid color? - while(!foundColor) - { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - // by convention, start at 1 - if(offset == 0) - { - forbidden[0] = true; - } + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - // Check neighbors, fill forbidden array. - for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) - { - nnz_lno_t vid_1idx = _adj(vid_1adj); + // Do multiple passes if the array is too small. + // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations + // but in distance-2 we'd need the total_time vertices at distance-2 which we don't easily have aprioi. + // This could be as big as all the vertices in the graph if diameter(G)=2... + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; - for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + while(!foundColor) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); - - // Skip distance-2-self-loops - if(vid_2idx == vid || vid_2idx >= nv) + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + // by convention, start at 1 + if(offset == 0) { - continue; + forbidden[0] = true; } - color_t c = _colors(vid_2idx); - - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + // Check neighbors, fill forbidden array. + for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) { - forbidden[c - offset] = true; + nnz_lno_t vid_1idx = _adj(vid_1adj); + + for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + { + nnz_lno_t vid_2idx = _t_adj(vid_2adj); + + // Skip distance-2-self-loops + if(vid_2idx == vid || vid_2idx >= nv) + { + continue; + } + + color_t c = _colors(vid_2idx); + + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + forbidden[c - offset] = true; + } + } } - } - } - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // for offset... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColor (end) + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // for offset... + } + } + }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColor (end) From 012f1d653e0deaa9d2814a1d768b995bc237a0b6 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 5 Jun 2018 17:13:13 -0600 Subject: [PATCH 013/190] development snapshot --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 6d85fdef84..87ca83f607 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -350,7 +350,10 @@ class GraphColorD2 // Experimental //Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO) , gc); // WCMCLEN - attempt - Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, chunkSize_) , gc); // WCMCLEN - attempt + const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); + Kokkos::parallel_for(policy_inst, gc); // WCMCLEN - attempt + +// Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, chunkSize_) , gc); // WCMCLEN - attempt } // colorGreedy (end) @@ -608,14 +611,15 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(team_member_t &thread) const + void operator()(const team_member_t &thread) const { nnz_lno_t vid_ = thread.league_rank() * thread.team_size() + thread.team_rank(); // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; nnz_lno_t vid = 0; // for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) // WCMCLEN: would change to a parallel_for - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) + { if(vid_ * _chunkSize + ichunk < _vertexListLength) { vid = _vertexList(vid_ * _chunkSize + ichunk); From f41067972719622b170cdf4cb68bf8721b2c8976 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 7 Jun 2018 13:08:20 -0600 Subject: [PATCH 014/190] Removing continues from FindConflicts --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 7 +- src/graph/KokkosGraph_Distance2Color.hpp | 1 + src/graph/KokkosGraph_GraphColorHandle.hpp | 6 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 68 +++++++++---------- 4 files changed, 40 insertions(+), 42 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 3d1153ba28..e848f69457 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -111,7 +111,7 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << std::endl << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl << spaces << " COLORING_D2_MATRIX_SQUARED - Distance-2 coloring using matrix-squared + Distance-1 coloring method." << std::endl - << spaces << " COLORING_D2 - Distance-2 coloring using traversal based method." << std::endl + << spaces << " COLORING_D2_VB - Distance-2 coloring using traversal based method." << std::endl << std::endl << spaces << " Optional Parameters:" << std::endl << spaces << " chunksize Set the chunk size." << std::endl @@ -185,7 +185,8 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 1; got_required_param_algorithm = true; } - else if(0 == strcasecmp(argv[i], "COLORING_D2")) + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || + 0 == strcasecmp(argv[i], "COLORING_D2") ) { params.algorithm = 2; got_required_param_algorithm = true; @@ -302,7 +303,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) label_algorithm = "COLORING_D2_MATRIX_SQUARED"; break; case 2: - kh.create_graph_coloring_handle(COLORING_D2); + kh.create_graph_coloring_handle(COLORING_D2_VB); label_algorithm = "COLORING_D2"; break; default: diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 32ab5637f3..7171e571b1 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -93,6 +93,7 @@ void graph_color_d2(KernelHandle *handle, } case COLORING_D2: + case COLORING_D2_VB: { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index de7b927019..e230d8d21f 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -58,8 +58,9 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_EB, COLORING_SERIAL2, COLORING_SPGEMM, - COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring (Brian's Code) - COLORING_D2 // Distance-2 Graph Coloring (WCMCLEN) + COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring + COLORING_D2, // Distance-2 Graph Coloring + COLORING_D2_VB // Distance-2 Graph Coloring Vertex Based }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -608,6 +609,7 @@ class GraphColoringHandle case COLORING_SPGEMM: case COLORING_D2_MATRIX_SQUARED: case COLORING_D2: + case COLORING_D2_VB: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 87ca83f607..e889ce767e 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -191,8 +191,6 @@ class GraphColorD2 << "\t serialConflictResolution : " << (int)this->_serialConflictResolution << std::endl << "\t chunkSize : " << this->_chunkSize << std::endl << "\t use_color_set : " << (int)this->_use_color_set << std::endl -// << "\t team_size : " << (int)gc_handle->get_suggested_team_size() << std::endl -// << "\t team_size : " << team_policy_t::team_size_max() << std::endl << "\tgraph information:" << std::endl << "\t nv : " << this->nv << std::endl << "\t ne : " << this->ne << std::endl; @@ -343,17 +341,14 @@ class GraphColorD2 chunkSize_ = 1; } - functorGreedyColor gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - // This one works but no team policy + // No Team Policy //Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); - // Experimental - //Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO) , gc); // WCMCLEN - attempt + // Team Policy const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); - Kokkos::parallel_for(policy_inst, gc); // WCMCLEN - attempt - -// Kokkos::parallel_for(team_policy_t(current_vertexListLength_ / chunkSize_ + 1, chunkSize_) , gc); // WCMCLEN - attempt + Kokkos::parallel_for(policy_inst, gc); } // colorGreedy (end) @@ -575,7 +570,7 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. */ - struct functorGreedyColor + struct functorGreedyColorVB { nnz_lno_t nv; // num vertices const_lno_row_view_t _idx; // vertex degree list @@ -587,15 +582,15 @@ class GraphColorD2 nnz_lno_t _vertexListLength; // nnz_lno_t _chunkSize; // - functorGreedyColor(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) + functorGreedyColorVB(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength), _chunkSize(chunkSize) { @@ -617,7 +612,7 @@ class GraphColorD2 // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; nnz_lno_t vid = 0; - // for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) // WCMCLEN: would change to a parallel_for + // for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) // NON-TEAM-POLICY Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { if(vid_ * _chunkSize + ichunk < _vertexListLength) @@ -733,32 +728,31 @@ class GraphColorD2 size_type vid_1adj = _idx(vid); size_type vid_1adj_end = _idx(vid + 1); - for(; vid_1adj < vid_1adj_end; vid_1adj++) + bool break_out = false; + + for(; !break_out && vid_1adj < vid_1adj_end; vid_1adj++) { nnz_lno_t vid_1idx = _adj(vid_1adj); - bool break_out = false; - - for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + for(size_type vid_2adj = _t_idx(vid_1idx); !break_out && vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) { nnz_lno_t vid_2idx = _t_adj(vid_2adj); - if(vid == vid_2idx || vid_2idx >= nv) - continue; - - if(_colors(vid_2idx) == my_color) + if(vid != vid_2idx && vid_2idx < nv) { - _colors(vid) = 0; // uncolor vertex - // Atomically add vertex to recolorList - const nnz_lno_t k = Kokkos::atomic_fetch_add(&_recolorListLength(), atomic_incr_type(1)); - _recolorList(k) = vid; - numConflicts += 1; - break_out = true; - break; // Can exit if vertex gets marked as a conflict. + if(_colors(vid_2idx) == my_color) + { + _colors(vid) = 0; // uncolor vertex + + // Atomically add vertex to recolorList + const nnz_lno_t k = Kokkos::atomic_fetch_add(&_recolorListLength(), atomic_incr_type(1)); + _recolorList(k) = vid; + numConflicts += 1; + break_out = true; + // break; // Can exit if vertex gets marked as a conflict. + } } } - if(break_out) - break; } } }; // struct functorFindConflicts_Atomic (end) From 276f112f8802fde77fddaa0570c80fa5367a6ccf Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 7 Jun 2018 15:34:19 -0600 Subject: [PATCH 015/190] Add COLORING_D2_VB and COLORING_D2_VBTP Updated the algorithm types to be more in-line with the stuff Mehmet did for his D1 coloring codes in terms of naming. - `COLORING_D2_VB` is the same as `COLORING_D2` - Will want to deprecate out the `COLORING_D2` flag eventually. - `COLORING_D2_VBTP` is the vertex based d2 coloring with team-policy stuff set up. The Team-Policy version builds and runs but needs work as it's currently not performant on OpenMP due to a big increase in the number of phases that are run. I haven't tested it much in CUDA --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 17 +- src/graph/KokkosGraph_Distance2Color.hpp | 1 + src/graph/KokkosGraph_GraphColorHandle.hpp | 11 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 180 ++++++++++++++++-- 4 files changed, 190 insertions(+), 19 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index e848f69457..9f272adf7f 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -111,7 +111,8 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << std::endl << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl << spaces << " COLORING_D2_MATRIX_SQUARED - Distance-2 coloring using matrix-squared + Distance-1 coloring method." << std::endl - << spaces << " COLORING_D2_VB - Distance-2 coloring using traversal based method." << std::endl + << spaces << " COLORING_D2_VB - Distance-2 coloring using direct method." << std::endl + << spaces << " COLORING_D2_VBTP - Distance-2 coloring using direct method + Team Policy." << std::endl << std::endl << spaces << " Optional Parameters:" << std::endl << spaces << " chunksize Set the chunk size." << std::endl @@ -185,12 +186,16 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 1; got_required_param_algorithm = true; } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || - 0 == strcasecmp(argv[i], "COLORING_D2") ) + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || 0 == strcasecmp(argv[i], "COLORING_D2") ) { params.algorithm = 2; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP")) + { + params.algorithm = 3; + got_required_param_algorithm = true; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -304,7 +309,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) break; case 2: kh.create_graph_coloring_handle(COLORING_D2_VB); - label_algorithm = "COLORING_D2"; + label_algorithm = "COLORING_D2_VB"; + break; + case 3: + kh.create_graph_coloring_handle(COLORING_D2_VBTP); + label_algorithm = "COLORING_D2_VBTP"; break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 7171e571b1..5acc578dc3 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -94,6 +94,7 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2: case COLORING_D2_VB: + case COLORING_D2_VBTP: { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index e230d8d21f..51be252fe1 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -60,7 +60,8 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_SPGEMM, COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring COLORING_D2, // Distance-2 Graph Coloring - COLORING_D2_VB // Distance-2 Graph Coloring Vertex Based + COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based + COLORING_D2_VBTP // Distance-2 Graph Coloring Vertex Based w/ Team Policy }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -492,11 +493,12 @@ class GraphColoringHandle size_type new_num_edge = 0; typedef Kokkos::RangePolicy my_exec_space; - if ( + if ( 0 #if defined( KOKKOS_ENABLE_CUDA ) - Kokkos::Impl::is_same::value || + || Kokkos::Impl::is_same::value #endif - 0){ + ) + { int teamSizeMax = 0; @@ -610,6 +612,7 @@ class GraphColoringHandle case COLORING_D2_MATRIX_SQUARED: case COLORING_D2: case COLORING_D2_VB: + case COLORING_D2_VBTP: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index e889ce767e..66d2c455af 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -41,6 +41,7 @@ //@HEADER */ #include +#include #include #include @@ -183,6 +184,20 @@ class GraphColorD2 // adj = entries (view 1 dimension - [num_edges] - adjacency list ) if(this->_ticToc) { + switch(this->gc_handle->get_coloring_algo_type()) + { + case COLORING_D2: + case COLORING_D2_VB: + std::cout << ">>>>>>>>>> COLORING_D2 or COLORING_D2_VB" << std::endl; + break; + case COLORING_D2_VBTP: + std::cout << ">>>>>>>>>> COLORING_D2_VBTP" << std::endl; + break; + default: + std::cout << ">>>>>>>>>> Unknown Coloring Algorithm" << std::endl; + break; + } + std::cout << "\tcolor_graph_d2 params:" << std::endl << "\t algorithm : " << (int)this->_use_color_set << std::endl << "\t useConflictList : " << (int)this->_conflictList << std::endl @@ -333,7 +348,6 @@ class GraphColorD2 nnz_lno_temp_work_view_t current_vertexList_, nnz_lno_t current_vertexListLength_) { - // std::cout << ">>> WCMCLEN colorGreedy (KokkosGraph_Distance2Color_impl.hpp) <<<" << std::endl; nnz_lno_t chunkSize_ = this->_chunkSize; if(current_vertexListLength_ < 100 * chunkSize_) @@ -341,14 +355,30 @@ class GraphColorD2 chunkSize_ = 1; } - functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - // No Team Policy - //Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); + // Pick the right coloring algorithm to use based on which algorithm we're using + switch(this->gc_handle->get_coloring_algo_type()) + { + // Vertex Based without Team Policy + case COLORING_D2: + case COLORING_D2_VB: + { + functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); + } + break; - // Team Policy - const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); - Kokkos::parallel_for(policy_inst, gc); + // Vertex Based with Team Policy + case COLORING_D2_VBTP: + { + functorGreedyColorVBTP gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); + Kokkos::parallel_for(policy_inst, gc); + } + break; + default: + throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); + break; + } } // colorGreedy (end) @@ -510,7 +540,7 @@ class GraphColorD2 // ------------------------------------------------------ - // Functors: Helpers + // Functions: Helpers // ------------------------------------------------------ @@ -567,7 +597,7 @@ class GraphColorD2 - /** + /** * Functor for VB algorithm speculative coloring without edge filtering. */ struct functorGreedyColorVB @@ -583,6 +613,134 @@ class GraphColorD2 nnz_lno_t _chunkSize; // functorGreedyColorVB(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t vid_) const + { + // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; + nnz_lno_t vid = 0; + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + if(vid_ * _chunkSize + ichunk < _vertexListLength) + vid = _vertexList(vid_ * _chunkSize + ichunk); + else + continue; + + // Already colored this vertex. + if(_colors(vid) > 0) + { + continue; + } + + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations + // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. + // This could be as big as all the vertices in the graph if diameter(G)=2... + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + // by convention, start at 1 + if(offset == 0) + { + forbidden[0] = true; + } + + // Check neighbors, fill forbidden array. + for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) + { + nnz_lno_t vid_1idx = _adj(vid_1adj); + + for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + { + nnz_lno_t vid_2idx = _t_adj(vid_2adj); + + // Skip distance-2-self-loops + if(vid_2idx == vid || vid_2idx >= nv) + { + continue; + } + + color_t c = _colors(vid_2idx); + + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + forbidden[c - offset] = true; + } + } + } + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // for offset... + } // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVB (end) + + + + + + + + + + /** + * Functor for VB algorithm speculative coloring without edge filtering. + * Team Policy Enabled + */ + struct functorGreedyColorVBTP + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColorVBTP(nnz_lno_t nv_, const_lno_row_view_t xadj_, const_lno_nnz_view_t adj_, const_clno_row_view_t t_xadj_, @@ -686,7 +844,7 @@ class GraphColorD2 } }); // for ichunk... } // operator() (end) - }; // struct functorGreedyColor (end) + }; // struct functorGreedyColorVBTP (end) From 49b3ce245b5bee77f6d611bea7dba3dfd622f043 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 7 Jun 2018 15:48:12 -0600 Subject: [PATCH 016/190] Removed unreachable code --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 66d2c455af..b317fbbefb 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -377,7 +377,6 @@ class GraphColorD2 break; default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); - break; } } // colorGreedy (end) From 70026b0acfed344309bc813847777f1cadbcc97a Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 7 Jun 2018 15:51:01 -0600 Subject: [PATCH 017/190] STYLE: Cleanup --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index b317fbbefb..00dc863a24 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -184,20 +184,6 @@ class GraphColorD2 // adj = entries (view 1 dimension - [num_edges] - adjacency list ) if(this->_ticToc) { - switch(this->gc_handle->get_coloring_algo_type()) - { - case COLORING_D2: - case COLORING_D2_VB: - std::cout << ">>>>>>>>>> COLORING_D2 or COLORING_D2_VB" << std::endl; - break; - case COLORING_D2_VBTP: - std::cout << ">>>>>>>>>> COLORING_D2_VBTP" << std::endl; - break; - default: - std::cout << ">>>>>>>>>> Unknown Coloring Algorithm" << std::endl; - break; - } - std::cout << "\tcolor_graph_d2 params:" << std::endl << "\t algorithm : " << (int)this->_use_color_set << std::endl << "\t useConflictList : " << (int)this->_conflictList << std::endl From 35e774f4b60f41d294599168ed861936c11ea3d5 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 12 Jun 2018 15:50:29 -0600 Subject: [PATCH 018/190] Add graphToGraphviz() to Graph Kernel Handle --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 11 +++ src/graph/KokkosGraph_GraphColorHandle.hpp | 73 ++++++++++++++++++- 2 files changed, 83 insertions(+), 1 deletion(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 9f272adf7f..ba2e986617 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -330,6 +330,17 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; + if(verbose && repeat==i+1 && crsGraph.numRows() < 1000) + { + auto colors = kh.get_graph_coloring_handle()->get_vertex_colors(); + std::ofstream os("G.dot", std::ofstream::out); + kh.get_graph_coloring_handle()->graphToGraphviz(os, + crsGraph.numRows(), + crsGraph.row_map, + crsGraph.entries, + colors); + } + total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); total_colors += kh.get_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_graph_coloring_handle()->get_num_phases(); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 51be252fe1..31a9bd8d3a 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -40,6 +40,9 @@ // ************************************************************************ //@HEADER */ +#include +#include + #include #include #include @@ -643,7 +646,6 @@ class GraphColoringHandle virtual ~GraphColoringHandle(){}; - //getters ColoringAlgorithm get_coloring_algo_type() const {return this->coloring_algorithm_type;} ConflictList get_conflict_list_type() const {return this->conflict_list_type;} @@ -690,6 +692,75 @@ class GraphColoringHandle } + // Print / write out the graph in a GraphVIZ format. + // Color "1" will be rendered as a red circle. + // Color "0" (uncolored) will be a star shape. + // Other node colors shown as just the color value. + // + // @param os use std::cout for output to STDOUT stream, or a ofstream object + // (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write + // to a file. + template + void graphToGraphviz(std::ostream &os, + const index_t num_verts, + rowmap_t &rowmap, + entries_t &entries, + kokkos_view_t &colors) const + { + typedef typename kokkos_view_t::HostMirror h_colors_t; + typedef typename rowmap_t::HostMirror h_rowmap_t; + typedef typename entries_t::HostMirror h_entries_t; + + h_colors_t h_colors = Kokkos::create_mirror_view(colors); + Kokkos::deep_copy(h_colors, colors); + + h_rowmap_t h_rowmap = Kokkos::create_mirror_view(rowmap); + Kokkos::deep_copy(h_rowmap, rowmap); + + h_entries_t h_entries = Kokkos::create_mirror_view(entries); + Kokkos::deep_copy(h_entries, entries); + + + os << "Graph G" << std::endl + << "{" << std::endl + << " rankdir=LR;" << std::endl + << " overlap=false;" << std::endl + << " splines=true;" << std::endl + << " maxiter=2000;" << std::endl + << " node [shape=Mrecord];" << std::endl + << " edge [len=2.0];" << std::endl + << std::endl; + + for(index_t vid = 0; vid < num_verts; vid++) + { + if(1 == h_colors(vid)) + { + os << " " << vid << " [ label=\"\", shape=circle, style=filled, color=red, fillcolor=red];" << std::endl; + } + else if(0 == h_colors(vid)) + { + os << " " << vid << " [ label=\"" << vid << "\", shape=star, style=filled, color=black];" << std::endl; + } + else + { + os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; + } + for(index_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) + { + index_t vadj = h_entries(iadj); + if(vadj >= vid) + { + os << " " << vid << " -- " << vadj << ";" << std::endl; + } + } + os << std::endl; + } + os << "}" << std::endl; + } // graphToGraphviz (end) + + + + }; } // namespace KokkosGraph From b20bedaa5caed908492db58355816ba3d3625ae5 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 12 Jun 2018 16:23:59 -0600 Subject: [PATCH 019/190] TeamPolicy handling for CUDA vs. not-CUDA --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 00dc863a24..c884548aa2 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -357,7 +357,13 @@ class GraphColorD2 case COLORING_D2_VBTP: { functorGreedyColorVBTP gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + + #if defined( KOKKOS_ENABLE_CUDA ) const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); + #else + const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO); + #endif + Kokkos::parallel_for(policy_inst, gc); } break; @@ -751,21 +757,17 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const team_member_t &thread) const { - nnz_lno_t vid_ = thread.league_rank() * thread.team_size() + thread.team_rank(); + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; - nnz_lno_t vid = 0; - // for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) // NON-TEAM-POLICY Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { - if(vid_ * _chunkSize + ichunk < _vertexListLength) + if(chunk_id * _chunkSize + ichunk < _vertexListLength) { - vid = _vertexList(vid_ * _chunkSize + ichunk); + nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); // Already colored this vertex. if(_colors(vid) <= 0) { - bool foundColor = false; // Have we found a valid color? // Use forbidden array to find available color. From 21ec9cd247a1e0efcd1c331618f021e20dc12ebd Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 12 Jun 2018 17:07:08 -0600 Subject: [PATCH 020/190] snapshot for testing on White --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 71 +++++++++---------- 1 file changed, 35 insertions(+), 36 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index c884548aa2..e6199f19fd 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -564,11 +564,14 @@ class GraphColorD2 + public: + + + // ------------------------------------------------------ // Functors: Distance-2 Graph Coloring // ------------------------------------------------------ - public: /** * Functor to init a list sequentialy, that is list[i] = i */ @@ -709,12 +712,6 @@ class GraphColorD2 - - - - - - /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled @@ -763,7 +760,7 @@ class GraphColorD2 { if(chunk_id * _chunkSize + ichunk < _vertexListLength) { - nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); // Already colored this vertex. if(_colors(vid) <= 0) @@ -772,45 +769,46 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + // - If more levels of parallelism are addd in the loops over neighbors, then + // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors // Do multiple passes if the array is too small. - // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total_time vertices at distance-2 which we don't easily have aprioi. - // This could be as big as all the vertices in the graph if diameter(G)=2... // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). color_t offset = 0; - while(!foundColor) + while(!foundColor && offset < nv) { // initialize for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - // by convention, start at 1 - if(offset == 0) + + // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for + // UNCOLORED vertices so we should start coloring at 1. + if(0 == offset) { forbidden[0] = true; } - // Check neighbors, fill forbidden array. - for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) + // Loop over neighbors + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) { - nnz_lno_t vid_1idx = _adj(vid_1adj); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - // Skip distance-2-self-loops - if(vid_2idx == vid || vid_2idx >= nv) + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) { - continue; - } - - color_t c = _colors(vid_2idx); + color_t c = _colors(vid_d2); - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - forbidden[c - offset] = true; + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + forbidden[c - offset] = true; + } } } } @@ -826,11 +824,12 @@ class GraphColorD2 } } // for c... offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // for offset... - } - } - }); // for ichunk... - } // operator() (end) + } // while(!foundColor) + } // if _colors(vid) <= 0 ... + } // if chunk_id*... + }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTP (end) @@ -867,11 +866,11 @@ class GraphColorD2 void operator()(const nnz_lno_t vid_, nnz_lno_t &numConflicts) const { typedef typename std::remove_reference::type atomic_incr_type; - nnz_lno_t vid = _vertexList(vid_); + const nnz_lno_t vid = _vertexList(vid_); color_t my_color = _colors(vid); size_type vid_1adj = _idx(vid); - size_type vid_1adj_end = _idx(vid + 1); + const size_type vid_1adj_end = _idx(vid + 1); bool break_out = false; @@ -881,7 +880,7 @@ class GraphColorD2 for(size_type vid_2adj = _t_idx(vid_1idx); !break_out && vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); + const nnz_lno_t vid_2idx = _t_adj(vid_2adj); if(vid != vid_2idx && vid_2idx < nv) { From 7644d857f369b0c29d01f57a156f0dd3a3eb4c32 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 12 Jun 2018 18:00:47 -0600 Subject: [PATCH 021/190] testing atomic_or --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index e6199f19fd..a049b72d66 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -807,7 +807,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - forbidden[c - offset] = true; + Kokkos::atomic_fetch_or(&forbidden[c-offset], true); + // forbidden[c - offset] = true; } } } From 2ff7144686b14e745ba4e26a84f46c3a29cfd6c4 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 12 Jun 2018 18:19:56 -0600 Subject: [PATCH 022/190] Use atomic_fetch_or() to update forbidden list in inner loop --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index a049b72d66..edcba0beb6 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -807,8 +807,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - Kokkos::atomic_fetch_or(&forbidden[c-offset], true); - // forbidden[c - offset] = true; + //Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + forbidden[c - offset] = true; } } } From d2ee48cf783e13732f7e9e8845115dfad92d1e59 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 13 Jun 2018 18:22:30 -0600 Subject: [PATCH 023/190] COB 20180613 Snapshot --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 18 + src/graph/KokkosGraph_Distance2Color.hpp | 2 + src/graph/KokkosGraph_GraphColorHandle.hpp | 6 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 308 +++++++++++++++++- 4 files changed, 332 insertions(+), 2 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index ba2e986617..c89bf7da2f 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -196,6 +196,16 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 3; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP2")) + { + params.algorithm = 4; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP3")) + { + params.algorithm = 5; + got_required_param_algorithm = true; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -315,6 +325,14 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VBTP); label_algorithm = "COLORING_D2_VBTP"; break; + case 4: + kh.create_graph_coloring_handle(COLORING_D2_VBTP2); + label_algorithm = "COLORING_D2_VBTP2"; + break; + case 5: + kh.create_graph_coloring_handle(COLORING_D2_VBTP3); + label_algorithm = "COLORING_D2_VBTP3"; + break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 5acc578dc3..be65110a2b 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -95,6 +95,8 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2: case COLORING_D2_VB: case COLORING_D2_VBTP: + case COLORING_D2_VBTP2: + case COLORING_D2_VBTP3: { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 31a9bd8d3a..346c966142 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -64,7 +64,9 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring COLORING_D2, // Distance-2 Graph Coloring COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based - COLORING_D2_VBTP // Distance-2 Graph Coloring Vertex Based w/ Team Policy + COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy + COLORING_D2_VBTP2, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 2) + COLORING_D2_VBTP3 // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -616,6 +618,8 @@ class GraphColoringHandle case COLORING_D2: case COLORING_D2_VB: case COLORING_D2_VBTP: + case COLORING_D2_VBTP2: + case COLORING_D2_VBTP3: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index edcba0beb6..591e73b76c 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -367,6 +367,41 @@ class GraphColorD2 Kokkos::parallel_for(policy_inst, gc); } break; + + // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) + case COLORING_D2_VBTP2: + { + std::cout << ">>> Running D2 VBTP2 Coloring" << std::endl; + + functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + + #if defined( KOKKOS_ENABLE_CUDA ) + const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + #else + const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + #endif + + Kokkos::parallel_for(policy_inst, gc); + } + break; + + // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) + case COLORING_D2_VBTP3: + { + std::cout << ">>> Running D2 VBTP2 Coloring" << std::endl; + + functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + + #if defined( KOKKOS_ENABLE_CUDA ) + const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + #else + const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + #endif + + Kokkos::parallel_for(policy_inst, gc); + } + break; + default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); } @@ -830,11 +865,282 @@ class GraphColorD2 } // if chunk_id*... }); // for ichunk... } // operator() (end) - }; // struct functorGreedyColorVBTP (end) + /** + * Functor for VB algorithm speculative coloring without edge filtering. + * Team Policy Enabled + * - trying out removing the loop-over-chunks stuff + */ + struct functorGreedyColorVBTP2 + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // +// nnz_lno_t _chunkSize; // + + functorGreedyColorVBTP2(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength) +// nnz_lno_t chunkSize) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _vertexList(vertexList) + , _vertexListLength(vertexListLength) +// , _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t &thread) const + { +// nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); + +// Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) +// { +// if(chunk_id * _chunkSize + ichunk < _vertexListLength) +// { +// const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + const nnz_lno_t vid = _vertexList( thread.league_rank() * thread.team_size() + thread.team_rank() ); + +// std::cout << ">>> vid = " << vid << std::endl; + + // Already colored this vertex. + if(_colors(vid) <= 0) + { + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + // - If more levels of parallelism are addd in the loops over neighbors, then + // atomics will be necessary for updating this. + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor && offset < nv) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + + // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for + // UNCOLORED vertices so we should start coloring at 1. + if(0 == offset) + { + forbidden[0] = true; + } + + // Loop over neighbors + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid+1) - _idx(vid) ), [&] (const size_type& idx) + { + size_type vid_d1_adj = idx + _idx(vid); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t c = _colors(vid_d2); + + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + } + } + } + }); + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // while(!foundColor) + } // if _colors(vid) <= 0 ... +// } // if chunk_id*... +// }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTP2 (end) + + + + + /** + * Functor for VB algorithm speculative coloring without edge filtering. + * Team Policy Enabled + * - trying out removing the loop-over-chunks stuff + */ + struct functorGreedyColorVBTP3 + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // +// nnz_lno_t _chunkSize; // + + functorGreedyColorVBTP3(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength) +// nnz_lno_t chunkSize) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _vertexList(vertexList) + , _vertexListLength(vertexListLength) +// , _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t &thread) const + { +// nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); + +// Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) +// { +// if(chunk_id * _chunkSize + ichunk < _vertexListLength) +// { +// const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + const nnz_lno_t vid = _vertexList( thread.league_rank() * thread.team_size() + thread.team_rank() ); + +// std::cout << ">>> vid = " << vid << std::endl; + + // Already colored this vertex. + if(_colors(vid) <= 0) + { + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + // - If more levels of parallelism are addd in the loops over neighbors, then + // atomics will be necessary for updating this. + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor && offset < nv) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + + // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for + // UNCOLORED vertices so we should start coloring at 1. + if(0 == offset) + { + forbidden[0] = true; + } + + // Loop over neighbors + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + + // Loop over distance-2 neighbors + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1+1) - _t_idx(vid_d1)), [&] (const size_type& idx) + { + size_type vid_d2_adj = idx + _t_idx(vid_d1); + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t c = _colors(vid_d2); + + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + } + } + }); + } + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // while(!foundColor) + } // if _colors(vid) <= 0 ... +// } // if chunk_id*... +// }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTP3 (end) + + + + + + + template struct functorFindConflicts_Atomic { From 88961fe4caec846e2349886eec5de46ec8e9d0c1 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Jun 2018 17:22:35 -0600 Subject: [PATCH 024/190] D2 Coloring with TeamPolicy (3 variants) --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 124 +++++++++--------- 1 file changed, 60 insertions(+), 64 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 591e73b76c..7d7463b4c3 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -341,6 +341,8 @@ class GraphColorD2 chunkSize_ = 1; } + size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; + // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) { @@ -359,9 +361,9 @@ class GraphColorD2 functorGreedyColorVBTP gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); #if defined( KOKKOS_ENABLE_CUDA ) - const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, chunkSize_); + const team_policy_t policy_inst(num_chunks, chunkSize_); #else - const team_policy_t policy_inst(current_vertexListLength_ / chunkSize_ + 1, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif Kokkos::parallel_for(policy_inst, gc); @@ -373,12 +375,12 @@ class GraphColorD2 { std::cout << ">>> Running D2 VBTP2 Coloring" << std::endl; - functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); #if defined( KOKKOS_ENABLE_CUDA ) - const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #else - const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif Kokkos::parallel_for(policy_inst, gc); @@ -388,14 +390,14 @@ class GraphColorD2 // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) case COLORING_D2_VBTP3: { - std::cout << ">>> Running D2 VBTP2 Coloring" << std::endl; + std::cout << ">>> Running D2 VBTP3 Coloring" << std::endl; - functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); #if defined( KOKKOS_ENABLE_CUDA ) - const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #else - const team_policy_t policy_inst(current_vertexListLength_, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif Kokkos::parallel_for(policy_inst, gc); @@ -884,7 +886,7 @@ class GraphColorD2 color_view_type _colors; // vertex colors nnz_lno_temp_work_view_t _vertexList; // nnz_lno_t _vertexListLength; // -// nnz_lno_t _chunkSize; // + nnz_lno_t _chunkSize; // functorGreedyColorVBTP2(nnz_lno_t nv_, const_lno_row_view_t xadj_, @@ -893,8 +895,8 @@ class GraphColorD2 const_clno_nnz_view_t t_adj_, color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength) -// nnz_lno_t chunkSize) + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) : nv(nv_) , _idx(xadj_) , _adj(adj_) @@ -903,7 +905,7 @@ class GraphColorD2 , _colors(colors) , _vertexList(vertexList) , _vertexListLength(vertexListLength) -// , _chunkSize(chunkSize) + , _chunkSize(chunkSize) { } @@ -919,16 +921,14 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const team_member_t &thread) const { -// nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - -// Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) -// { -// if(chunk_id * _chunkSize + ichunk < _vertexListLength) -// { -// const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - const nnz_lno_t vid = _vertexList( thread.league_rank() * thread.team_size() + thread.team_rank() ); + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); -// std::cout << ">>> vid = " << vid << std::endl; + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + const nnz_lno_t vertex_list_idx = chunk_id * _chunkSize + ichunk; + if(vertex_list_idx < _vertexListLength) + { + const nnz_lno_t vid = _vertexList(vertex_list_idx); // Already colored this vertex. if(_colors(vid) <= 0) @@ -959,29 +959,29 @@ class GraphColorD2 // Loop over neighbors for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid+1) - _idx(vid) ), [&] (const size_type& idx) - { - size_type vid_d1_adj = idx + _idx(vid); - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { + size_type vid_d1_adj = idx + _idx(vid); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) - { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { - color_t c = _colors(vid_d2); + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) { - Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + color_t c = _colors(vid_d2); + + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + Kokkos::atomic_fetch_or(&forbidden[c - offset], + true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + } } } - } - }); + }); // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) @@ -996,10 +996,10 @@ class GraphColorD2 offset += VB_D2_COLORING_FORBIDDEN_SIZE; } // while(!foundColor) } // if _colors(vid) <= 0 ... -// } // if chunk_id*... -// }); // for ichunk... + } // if vid_ * ...... + } // for ichunk... } // operator() (end) - }; // struct functorGreedyColorVBTP2 (end) + }; // struct functorGreedyColorVBTP2 (end) @@ -1019,7 +1019,7 @@ class GraphColorD2 color_view_type _colors; // vertex colors nnz_lno_temp_work_view_t _vertexList; // nnz_lno_t _vertexListLength; // -// nnz_lno_t _chunkSize; // + nnz_lno_t _chunkSize; // functorGreedyColorVBTP3(nnz_lno_t nv_, const_lno_row_view_t xadj_, @@ -1028,8 +1028,8 @@ class GraphColorD2 const_clno_nnz_view_t t_adj_, color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength) -// nnz_lno_t chunkSize) + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) : nv(nv_) , _idx(xadj_) , _adj(adj_) @@ -1038,7 +1038,7 @@ class GraphColorD2 , _colors(colors) , _vertexList(vertexList) , _vertexListLength(vertexListLength) -// , _chunkSize(chunkSize) + , _chunkSize(chunkSize) { } @@ -1054,16 +1054,14 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const team_member_t &thread) const { -// nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - -// Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) -// { -// if(chunk_id * _chunkSize + ichunk < _vertexListLength) -// { -// const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - const nnz_lno_t vid = _vertexList( thread.league_rank() * thread.team_size() + thread.team_rank() ); + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); -// std::cout << ">>> vid = " << vid << std::endl; + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + const nnz_lno_t vertex_list_idx = chunk_id * _chunkSize + ichunk; + if(vertex_list_idx < _vertexListLength) + { + const nnz_lno_t vid = _vertexList(vertex_list_idx); // Already colored this vertex. if(_colors(vid) <= 0) @@ -1098,9 +1096,8 @@ class GraphColorD2 const nnz_lno_t vid_d1 = _adj(vid_d1_adj); // Loop over distance-2 neighbors - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1+1) - _t_idx(vid_d1)), [&] (const size_type& idx) - { - size_type vid_d2_adj = idx + _t_idx(vid_d1); + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) { + size_type vid_d2_adj = idx + _t_idx(vid_d1); const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); // Skip distance-2 self loops @@ -1111,7 +1108,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + Kokkos::atomic_fetch_or(&forbidden[c - offset], + true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism } } }); @@ -1130,12 +1128,10 @@ class GraphColorD2 offset += VB_D2_COLORING_FORBIDDEN_SIZE; } // while(!foundColor) } // if _colors(vid) <= 0 ... -// } // if chunk_id*... -// }); // for ichunk... + } // if vertex_list_idx < _vertexListLength + } // for ichunk... } // operator() (end) - }; // struct functorGreedyColorVBTP3 (end) - - + }; // struct functorGreedyColorVBTP3 (end) From c42bea4403a3c5c6b401fceb597db6d06608fd84 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Jun 2018 19:03:03 -0600 Subject: [PATCH 025/190] Checkpoint 2018-06-14 --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 75 ++-- src/graph/KokkosGraph_Distance2Color.hpp | 2 + src/graph/KokkosGraph_GraphColorHandle.hpp | 6 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 334 ++++++++++++++++-- 4 files changed, 362 insertions(+), 55 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index c89bf7da2f..6b1c68ec7f 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -206,6 +206,16 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 5; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTPVR1")) + { + params.algorithm = 6; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTPVR2")) + { + params.algorithm = 7; + got_required_param_algorithm = true; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -306,39 +316,48 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) size_t total_phases = 0; std::string label_algorithm; + switch(algorithm) + { + case 1: + kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + break; + case 2: + kh.create_graph_coloring_handle(COLORING_D2_VB); + label_algorithm = "COLORING_D2_VB"; + break; + case 3: + kh.create_graph_coloring_handle(COLORING_D2_VBTP); + label_algorithm = "COLORING_D2_VBTP"; + break; + case 4: + kh.create_graph_coloring_handle(COLORING_D2_VBTP2); + label_algorithm = "COLORING_D2_VBTP2"; + break; + case 5: + kh.create_graph_coloring_handle(COLORING_D2_VBTP3); + label_algorithm = "COLORING_D2_VBTP3"; + break; + case 6: + kh.create_graph_coloring_handle(COLORING_D2_VBTPVR1); + label_algorithm = "COLORING_D2_VBTPVR1"; + break; + case 7: + kh.create_graph_coloring_handle(COLORING_D2_VBTPVR2); + label_algorithm = "COLORING_D2_VBTPVR2"; + break; + default: + kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + break; + } + + std::cout << ">>> Run Graph Color D2 (" << label_algorithm << ")" << std::endl; // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { - switch(algorithm) - { - case 1: - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; - break; - case 2: - kh.create_graph_coloring_handle(COLORING_D2_VB); - label_algorithm = "COLORING_D2_VB"; - break; - case 3: - kh.create_graph_coloring_handle(COLORING_D2_VBTP); - label_algorithm = "COLORING_D2_VBTP"; - break; - case 4: - kh.create_graph_coloring_handle(COLORING_D2_VBTP2); - label_algorithm = "COLORING_D2_VBTP2"; - break; - case 5: - kh.create_graph_coloring_handle(COLORING_D2_VBTP3); - label_algorithm = "COLORING_D2_VBTP3"; - break; - default: - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; - break; - } - graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); std::cout << "Time : " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index be65110a2b..dc2b918433 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -97,6 +97,8 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_VBTP: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: + case COLORING_D2_VBTPVR1: + case COLORING_D2_VBTPVR2: { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 346c966142..c3b1fe2600 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -66,7 +66,9 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy COLORING_D2_VBTP2, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 2) - COLORING_D2_VBTP3 // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) + COLORING_D2_VBTP3, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) + COLORING_D2_VBTPVR1, // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 1) + COLORING_D2_VBTPVR2 // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 2) }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -620,6 +622,8 @@ class GraphColoringHandle case COLORING_D2_VBTP: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: + case COLORING_D2_VBTPVR1: + case COLORING_D2_VBTPVR2: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 7d7463b4c3..fc8a934f01 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -373,8 +373,6 @@ class GraphColorD2 // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) case COLORING_D2_VBTP2: { - std::cout << ">>> Running D2 VBTP2 Coloring" << std::endl; - functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); #if defined( KOKKOS_ENABLE_CUDA ) @@ -390,8 +388,6 @@ class GraphColorD2 // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) case COLORING_D2_VBTP3: { - std::cout << ">>> Running D2 VBTP3 Coloring" << std::endl; - functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); #if defined( KOKKOS_ENABLE_CUDA ) @@ -404,6 +400,34 @@ class GraphColorD2 } break; + case COLORING_D2_VBTPVR1: + { + functorGreedyColorVBTPVR1 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + + #if defined( KOKKOS_ENABLE_CUDA ) + const team_policy_t policy_inst(num_chunks, chunkSize_, 32); + #else + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); + #endif + + Kokkos::parallel_for(policy_inst, gc); + } + break; + + case COLORING_D2_VBTPVR2: + { + functorGreedyColorVBTPVR2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + + #if defined( KOKKOS_ENABLE_CUDA ) + const team_policy_t policy_inst(num_chunks, chunkSize_, 32); + #else + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); + #endif + + Kokkos::parallel_for(policy_inst, gc); + } + break; + default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); } @@ -958,30 +982,31 @@ class GraphColorD2 } // Loop over neighbors - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { - size_type vid_d1_adj = idx + _idx(vid); - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + //for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) + { + size_type vid_d1_adj = idx + _idx(vid); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + color_t c = _colors(vid_d2); - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - Kokkos::atomic_fetch_or(&forbidden[c - offset], - true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism - } + // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } - }); + } + }); // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) @@ -1003,7 +1028,6 @@ class GraphColorD2 - /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled @@ -1096,7 +1120,8 @@ class GraphColorD2 const nnz_lno_t vid_d1 = _adj(vid_d1_adj); // Loop over distance-2 neighbors - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) + { size_type vid_d2_adj = idx + _t_idx(vid_d1); const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); @@ -1108,8 +1133,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - Kokkos::atomic_fetch_or(&forbidden[c - offset], - true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism + Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } }); @@ -1135,6 +1160,263 @@ class GraphColorD2 + /** + * Functor for VB algorithm speculative coloring without edge filtering. + * Team Policy Enabled + * Vector Range Enabled + */ + struct functorGreedyColorVBTPVR1 + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColorVBTPVR1(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t &thread) const + { + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); + + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { + if(chunk_id * _chunkSize + ichunk < _vertexListLength) + { + const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + + // Already colored this vertex. + if(_colors(vid) <= 0) + { + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + // - If more levels of parallelism are addd in the loops over neighbors, then + // atomics will be necessary for updating this. + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor && offset < nv) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + + // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for + // UNCOLORED vertices so we should start coloring at 1. + if(0 == offset) + { + forbidden[0] = true; + } + + // Loop over neighbors + #if 0 + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + #else + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid+1) - _idx(vid)), [&] (const size_type &idx) + { + size_type vid_d1_adj = idx + _idx(vid); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + #endif + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t c = _colors(vid_d2); + + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel + //forbidden[c - offset] = true; + } + } + } + }); + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // while(!foundColor) + } // if _colors(vid) <= 0 ... + } // if chunk_id*... + }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTPVR1 (end) + + + + + /** + * Functor for VB algorithm speculative coloring without edge filtering. + * Team Policy Enabled + * Vector Range Enabled + */ + struct functorGreedyColorVBTPVR2 + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColorVBTPVR2(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t &thread) const + { + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); + + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { + if(chunk_id * _chunkSize + ichunk < _vertexListLength) + { + const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + + // Already colored this vertex. + if(_colors(vid) <= 0) + { + bool foundColor = false; // Have we found a valid color? + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + // - If more levels of parallelism are addd in the loops over neighbors, then + // atomics will be necessary for updating this. + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the array is too small. + // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). + color_t offset = 0; + + while(!foundColor && offset < nv) + { + // initialize + for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } + + // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for + // UNCOLORED vertices so we should start coloring at 1. + if(0 == offset) + { + forbidden[0] = true; + } + + // Loop over neighbors + #if 0 + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + #else + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid+1) - _idx(vid)), [&] (const size_type &idx) + { + size_type vid_d1_adj = idx + _idx(vid); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + #endif + // Loop over distance-2 neighbors + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + // Skip distance-2 self loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t c = _colors(vid_d2); + + // If color found is inside current 'range' then mark it as used. + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel + //forbidden[c - offset] = true; + } + } + } + }); + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + offset += VB_D2_COLORING_FORBIDDEN_SIZE; + } // while(!foundColor) + } // if _colors(vid) <= 0 ... + } // if chunk_id*... + }); // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTPVR2 (end) + + + template From af911d012bc431450b28fc76ac390adeb9468102 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Jun 2018 19:49:15 -0600 Subject: [PATCH 026/190] Checkpoint 2018-06-14 -2 --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 36 +++++++------------ 1 file changed, 12 insertions(+), 24 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index fc8a934f01..effe9a62ad 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1205,7 +1205,8 @@ class GraphColorD2 { nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) + { if(chunk_id * _chunkSize + ichunk < _vertexListLength) { const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); @@ -1238,16 +1239,9 @@ class GraphColorD2 } // Loop over neighbors - #if 0 - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - #else - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid+1) - _idx(vid)), [&] (const size_type &idx) - { - size_type vid_d1_adj = idx + _idx(vid); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { + size_type vid_d1_adj = idx + _idx(vid); const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - #endif // Loop over distance-2 neighbors for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { @@ -1261,8 +1255,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel - //forbidden[c - offset] = true; + // WCMCLEN SCAFFOLDING - For VectorLevel + Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } } @@ -1334,7 +1328,8 @@ class GraphColorD2 { nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) + { if(chunk_id * _chunkSize + ichunk < _vertexListLength) { const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); @@ -1367,16 +1362,9 @@ class GraphColorD2 } // Loop over neighbors - #if 0 - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - #else - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid+1) - _idx(vid)), [&] (const size_type &idx) - { - size_type vid_d1_adj = idx + _idx(vid); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { + size_type vid_d1_adj = idx + _idx(vid); const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - #endif // Loop over distance-2 neighbors for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { @@ -1390,8 +1378,8 @@ class GraphColorD2 // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel - //forbidden[c - offset] = true; + // WCMCLEN SCAFFOLDING - For VectorLevel + Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } } From 94f0a8063ca32a462b4c9bc5b60bf0255b0470b0 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 15 Jun 2018 20:20:43 -0600 Subject: [PATCH 027/190] Fixed timing accumulator problem --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 18 ++++++++---------- .../impl/KokkosGraph_Distance2Color_impl.hpp | 3 +++ 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 6b1c68ec7f..4f72c09613 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -308,12 +308,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) } // accumulators for average stats - double total_time = 0.0; - double total_time_color_greedy = 0.0; - double total_time_find_conflicts = 0.0; - double total_time_resolve_conflicts = 0.0; - size_t total_colors = 0; - size_t total_phases = 0; + size_t total_colors = 0; + size_t total_phases = 0; std::string label_algorithm; switch(algorithm) @@ -378,14 +374,15 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) colors); } - total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); total_colors += kh.get_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_graph_coloring_handle()->get_num_phases(); - total_time_color_greedy += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); - total_time_find_conflicts += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); - total_time_resolve_conflicts += kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); } + double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); + double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); + double total_time_find_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); + double total_time_resolve_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); + double avg_time = total_time / repeat; double avg_time_color_greedy = total_time_color_greedy / repeat; double avg_time_find_conflicts = total_time_find_conflicts / repeat; @@ -421,6 +418,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl << " Algorithm : " << label_algorithm << std::endl + << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl << " Avg Time CG : " << avg_time_color_greedy << std::endl << " Avg Time FC : " << avg_time_find_conflicts << std::endl diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index effe9a62ad..a50ecde6a3 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -227,6 +227,9 @@ class GraphColorD2 double total_time = 0.0; Kokkos::Impl::Timer timer; + // make sure the timer resets, just in case + timer.reset(); + int iter = 0; for(; (iter < _max_num_iterations) && (numUncolored > 0); iter++) { From 907e7213a93d003532f0460309377b420204dbc1 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 15 Jun 2018 22:45:31 -0600 Subject: [PATCH 028/190] Added COLORING_D2_SERIAL to KokkosGraph_color_d2_wcmclen - There were some places that I had to modify include files to load `KokkosGraph_GraphColor.hpp` rather than `KokkosGraph_graph_color.hpp` after I renamed some files for consistency. There were old headers still hanging around in my perf_test directories allowing compiles to complete. - Added COLORING_D2_SERIAL to the `KokkosGraph_color_d2_wcmclen` application. Eventually this application should replace the `KokkosGraph_color_d2` application. - Note: If you try to use COLORING_D2_SERIAL without building Kokkos-Kernels with `Serial` enabled then an error should get thrown. - I'm not *overly* familiar with the Serial code for the D2 algorithm, as best as I can tell it requires some stuff that's guarded by `#if defined KOKKOS_ENABLE_SERIAL` so I adde that guard in the source file as well. - Bug fix: aggregation timer for repeated runs (parameter repeat N) was fixed. --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 9 ++ src/graph/KokkosGraph_Distance2Color.hpp | 118 ++++++++++-------- src/graph/KokkosGraph_GraphColorHandle.hpp | 2 + ...raph_Distance2Color_MatrixSquared_impl.hpp | 2 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 8 +- .../impl/KokkosSparse_gauss_seidel_impl.hpp | 2 +- src/sparse/impl/KokkosSparse_spgemm_impl.hpp | 2 +- unit_test/graph/Test_Graph_graph_color.hpp | 2 +- unit_test/graph/Test_Graph_graph_color_d2.hpp | 2 +- 9 files changed, 88 insertions(+), 59 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 4f72c09613..7d7a1a25c4 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -216,6 +216,11 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 7; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) + { + params.algorithm = 8; + got_required_param_algorithm = true; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -342,6 +347,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VBTPVR2); label_algorithm = "COLORING_D2_VBTPVR2"; break; + case 8: + kh.create_graph_coloring_handle(COLORING_D2_SERIAL); + label_algorithm = "COLORING_D2_SERIAL"; + break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index dc2b918433..471304d438 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -43,6 +43,7 @@ #ifndef _KOKKOS_GRAPH_COLORD2_HPP #define _KOKKOS_GRAPH_COLORD2_HPP +#include "KokkosGraph_GraphColor_impl.hpp" #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" #include "KokkosGraph_GraphColorHandle.hpp" @@ -55,70 +56,87 @@ namespace Experimental{ // initial distance 2 graph coloring -- serial only (work in progress) - wcmclen -template +template void graph_color_d2(KernelHandle *handle, typename KernelHandle::nnz_lno_t num_rows, typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, + lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries) { - Kokkos::Impl::Timer timer; + Kokkos::Impl::Timer timer; - // Set our handle pointer to a GraphColoringHandleType. - typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); + // Set our handle pointer to a GraphColoringHandleType. + typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); - // Get the algorithm we're running from the graph coloring handle. - ColoringAlgorithm algorithm = gch->get_coloring_algo_type(); + // Get the algorithm we're running from the graph coloring handle. + ColoringAlgorithm algorithm = gch->get_coloring_algo_type(); - // Create a view to save the colors to. - // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) - // a 1D array of color_t - typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; - color_view_type colors_out("Graph Colors", num_rows); + // Create a view to save the colors to. + // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) + // a 1D array of color_t + typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; + color_view_type colors_out("Graph Colors", num_rows); - gch->set_tictoc( handle->get_verbose() ); + gch->set_tictoc(handle->get_verbose()); - switch (algorithm) - { - case COLORING_SPGEMM: // WCMCLEN: Remove SPGEMM coloring references for D2 Graph Coloring? - case COLORING_D2_MATRIX_SQUARED: + switch(algorithm) { - Impl::GraphColorD2_MatrixSquared - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.execute(); - break; + case COLORING_SPGEMM: // WCMCLEN: Remove SPGEMM coloring references for D2 Graph Coloring? + case COLORING_D2_MATRIX_SQUARED: + { + Impl::GraphColorD2_MatrixSquared + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + gc.execute(); + break; + } + + case COLORING_D2_SERIAL: + { + #if defined KOKKOS_ENABLE_SERIAL + int num_phases = 0; + std::cout << "KokkosGraph_Distance2Color.hpp::COLORING_D2_SERIAL" << std::endl; + Impl::GraphColor + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); + gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); + + // Save out the number of phases and vertex colors + gch->set_vertex_colors(colors_out); + gch->set_num_phases((double)num_phases); + #else + throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); + #endif + break; + } + + case COLORING_D2: + case COLORING_D2_VB: + case COLORING_D2_VBTP: + case COLORING_D2_VBTP2: + case COLORING_D2_VBTP3: + case COLORING_D2_VBTPVR1: + case COLORING_D2_VBTPVR2: + { + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + gc.execute(); + break; + } + + default: + { + break; + } } - case COLORING_D2: - case COLORING_D2_VB: - case COLORING_D2_VBTP: - case COLORING_D2_VBTP2: - case COLORING_D2_VBTP3: - case COLORING_D2_VBTPVR1: - case COLORING_D2_VBTPVR2: - { - Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.execute(); - break; - } - - default: - { - break; - } - } - - double coloring_time = timer.seconds(); - gch->add_to_overall_coloring_time(coloring_time); - gch->set_coloring_time(coloring_time); + double coloring_time = timer.seconds(); + gch->add_to_overall_coloring_time(coloring_time); + gch->set_coloring_time(coloring_time); } -} // end namespace Experimental -} // end namespace KokkosGraph - -#endif //_KOKKOS_GRAPH_COLOR_HPP +} // end namespace Experimental +} // end namespace KokkosGraph +#endif //_KOKKOS_GRAPH_COLOR_HPP diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index c3b1fe2600..7c3e697c98 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -62,6 +62,7 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_SERIAL2, COLORING_SPGEMM, COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring + COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) COLORING_D2, // Distance-2 Graph Coloring COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy @@ -617,6 +618,7 @@ class GraphColoringHandle case COLORING_SERIAL2: case COLORING_SPGEMM: case COLORING_D2_MATRIX_SQUARED: + case COLORING_D2_SERIAL: case COLORING_D2: case COLORING_D2_VB: case COLORING_D2_VBTP: diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 599d805d9f..0862cce7f3 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -50,7 +50,7 @@ #include #include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" #include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2MATRIXSQUAREDIMP_HPP diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index a50ecde6a3..b973061938 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -51,7 +51,7 @@ #include #include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" #include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2IMP_HPP @@ -113,6 +113,7 @@ class GraphColorD2 protected: + nnz_lno_t nv; // num vertices nnz_lno_t nr; // num_rows (# verts) nnz_lno_t nc; // num cols size_type ne; // # edges @@ -120,7 +121,6 @@ class GraphColorD2 const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices typename HandleType::GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle @@ -142,7 +142,7 @@ class GraphColorD2 * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorD2(nnz_lno_t nr_, + GraphColorD2(nnz_lno_t nv_, nnz_lno_t nc_, size_type ne_, const_lno_row_view_t row_map, @@ -150,7 +150,7 @@ class GraphColorD2 const_clno_row_view_t t_row_map, const_clno_nnz_view_t t_entries, HandleType *handle) - : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), + : nv(nv_), nr(nv_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1), _serialConflictResolution(false), _use_color_set(0), _ticToc(handle->get_verbose()) diff --git a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp index 160390b9b2..8184cea08a 100644 --- a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp +++ b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp @@ -47,7 +47,7 @@ #include #include #include -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" #include "KokkosKernels_Uniform_Initialized_MemoryPool.hpp" #ifndef _KOKKOSGSIMP_HPP #define _KOKKOSGSIMP_HPP diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl.hpp index 2fdc4cb3cc..8ada468639 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl.hpp @@ -64,7 +64,7 @@ #include "KokkosKernels_HashmapAccumulator.hpp" #include "KokkosKernels_Uniform_Initialized_MemoryPool.hpp" #include "KokkosSparse_spgemm_handle.hpp" -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" namespace KokkosSparse{ diff --git a/unit_test/graph/Test_Graph_graph_color.hpp b/unit_test/graph/Test_Graph_graph_color.hpp index f42c4f1e4c..7231024d05 100644 --- a/unit_test/graph/Test_Graph_graph_color.hpp +++ b/unit_test/graph/Test_Graph_graph_color.hpp @@ -44,7 +44,7 @@ #include #include -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" #include "KokkosSparse_CrsMatrix.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_SparseUtils.hpp" diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_d2.hpp index 29729b3763..1867e643cd 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_d2.hpp @@ -44,7 +44,7 @@ #include #include -#include "KokkosGraph_graph_color_d2.hpp" +#include "KokkosGraph_Distance2Color.hpp" #include "KokkosSparse_CrsMatrix.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_SparseUtils.hpp" From 2ed1c1e105619fae35e001ffa67fe31803ebe3a7 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 15 Jun 2018 23:25:28 -0600 Subject: [PATCH 029/190] Style: correct a label in a cout --- perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 7d7a1a25c4..93c0b3445a 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -365,7 +365,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); - std::cout << "Time : " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl + std::cout << "Total Time: " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; std::cout << "\t"; From 3a5d8b15c6417d45c7530da4bdd04f5ccabf1e85 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 18 Jun 2018 15:08:51 -0600 Subject: [PATCH 030/190] bugfix - VBTPVR2 loop structure --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 46 +++++++++++-------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index b973061938..64d7d2699e 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -222,6 +222,7 @@ class GraphColorD2 nnz_lno_t numUncolored = this->nv; nnz_lno_t current_vertexListLength = this->nv; + nnz_lno_t previous_vertexListLength = this->nv; double time; double total_time = 0.0; @@ -244,7 +245,12 @@ class GraphColorD2 { time = timer.seconds(); total_time += time; - std::cout << "\tTime speculative greedy phase " << std::setw(-2) << iter << " : " << time << std::endl; + std::cout << "\tIteration: " << iter << std::endl + << "\t - Time speculative greedy phase : " << time << std::endl + << "\t - num 'active' vertices : " << current_vertexListLength << " (" << current_vertexListLength - previous_vertexListLength << ")" << std::endl; + + previous_vertexListLength = current_vertexListLength; + timer.reset(); gc_handle->add_to_overall_coloring_time_phase1(time); } @@ -275,7 +281,7 @@ class GraphColorD2 { time = timer.seconds(); total_time += time; - std::cout << "\tTime conflict detection " << std::setw(-2) << iter << " : " << time << std::endl; + std::cout << "\t - Time conflict detection " << " : " << time << std::endl; timer.reset(); gc_handle->add_to_overall_coloring_time_phase2(time); } @@ -311,7 +317,7 @@ class GraphColorD2 { time = timer.seconds(); total_time += time; - std::cout << "\tTime serial conflict resolution : " << time << std::endl; + std::cout << "\tTime serial conflict resolution : " << time << std::endl; gc_handle->add_to_overall_coloring_time_phase3(time); } @@ -410,7 +416,7 @@ class GraphColorD2 #if defined( KOKKOS_ENABLE_CUDA ) const team_policy_t policy_inst(num_chunks, chunkSize_, 32); #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 32); #endif Kokkos::parallel_for(policy_inst, gc); @@ -657,6 +663,7 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. + * Single level parallelism */ struct functorGreedyColorVB { @@ -778,7 +785,7 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled + * Team Policy Enabled on loop over chunks */ struct functorGreedyColorVBTP { @@ -900,8 +907,8 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled - * - trying out removing the loop-over-chunks stuff + * Team Policy Enabled on loop over neighbors + * - Serialized the loop over chunks */ struct functorGreedyColorVBTP2 { @@ -1165,8 +1172,8 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled - * Vector Range Enabled + * Team Policy Enabled on loop over chunks + * Vector Range Enabled on loop over neighbors of neighbors TODO: Make it so! */ struct functorGreedyColorVBTPVR1 { @@ -1288,8 +1295,8 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled - * Vector Range Enabled + * Team Policy Enabled on loop-over -chunks + * Vector Range Enabled on loop-over-neighbors */ struct functorGreedyColorVBTPVR2 { @@ -1364,13 +1371,14 @@ class GraphColorD2 forbidden[0] = true; } - // Loop over neighbors - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { - size_type vid_d1_adj = idx + _idx(vid); - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + // Check neighbors, fill forbidden array. + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + { + nnz_lno_t vid_d1 = _adj(vid_d1_adj); + // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) - { + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _t_idx(vid_d1+1) - _t_idx(vid_d1)), [&](const size_type &idx) { + const size_type vid_d2_adj = idx + _t_idx(vid); const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); // Skip distance-2 self loops @@ -1385,8 +1393,8 @@ class GraphColorD2 Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } - } - }); + }); // for vid_d2_adj... + } // for vid_d1_adj... // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) From aa12cde514d91753fc9f6a79d82339262fdee8a3 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 18 Jun 2018 15:51:37 -0600 Subject: [PATCH 031/190] Cleaning up Distance2Color_impl --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 316 +++++++++--------- 1 file changed, 161 insertions(+), 155 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 64d7d2699e..56189ca784 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -50,8 +50,8 @@ #include #include -#include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2IMP_HPP @@ -108,8 +108,8 @@ class GraphColorD2 typedef Kokkos::RangePolicy my_exec_space; - typedef Kokkos::TeamPolicy team_policy_t ; - typedef typename team_policy_t::member_type team_member_t ; + typedef Kokkos::TeamPolicy team_policy_t; + typedef typename team_policy_t::member_type team_member_t; protected: @@ -204,7 +204,7 @@ class GraphColorD2 nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); // init conflictlist sequentially. - Kokkos::parallel_for(my_exec_space(0, this->nv), functorInitList(current_vertexList)); + Kokkos::parallel_for("InitList", my_exec_space(0, this->nv), functorInitList(current_vertexList)); // Next iteratons's conflictList nnz_lno_temp_work_view_t next_iteration_recolorList; @@ -220,8 +220,8 @@ class GraphColorD2 next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); } - nnz_lno_t numUncolored = this->nv; - nnz_lno_t current_vertexListLength = this->nv; + nnz_lno_t numUncolored = this->nv; + nnz_lno_t current_vertexListLength = this->nv; nnz_lno_t previous_vertexListLength = this->nv; double time; @@ -307,8 +307,7 @@ class GraphColorD2 // ------------------------------------------ if(numUncolored > 0) { - this->resolveConflicts( - this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + this->resolveConflicts(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } MyExecSpace::fence(); @@ -350,96 +349,122 @@ class GraphColorD2 chunkSize_ = 1; } - size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; + const size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) { - // Vertex Based without Team Policy + // Single level parallelism on chunks + // 1. [P] loop over chunks of vertices + // 2. [S] loop over vertices in chunks + // 3. [S] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2: case COLORING_D2_VB: - { + { functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for(my_exec_space(0, current_vertexListLength_ / chunkSize_ + 1), gc); - } - break; + Kokkos::parallel_for("VB_LoopOverChunks", my_exec_space(0, num_chunks), gc); + } + break; - // Vertex Based with Team Policy + // Two level parallelism: + // 1. [P] loop over chunks of vertices + // 2. [P] loop over vertices in chunks + // 3. [S] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VBTP: - { + { functorGreedyColorVBTP gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - #if defined( KOKKOS_ENABLE_CUDA ) + #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, chunkSize_); #else const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif - Kokkos::parallel_for(policy_inst, gc); - } - break; + Kokkos::parallel_for("VBTP_LoopOverChunks", policy_inst, gc); + } + break; - // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) + // Two level parallelism: + // 1. [P] loop over chunks of vertices + // 2. [S] loop over vertices in chunks + // 3. [P] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VBTP2: - { + { functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - #if defined( KOKKOS_ENABLE_CUDA ) + #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #else const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif - Kokkos::parallel_for(policy_inst, gc); - } - break; + Kokkos::parallel_for("VBTP2_LoopOverChunks", policy_inst, gc); + } + break; - // Vertex Based with Team Policy WCMCLEN SCAFFOLDING (EXPERIMENTAL) + // Two level parallelism: + // 1. [P] loop over chunks of vertices + // 2. [S] loop over vertices in chunks + // 3. [S] loop over vertex neighbors + // 4. [P] loop over vertex neighbors of neighbors case COLORING_D2_VBTP3: - { + { functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - #if defined( KOKKOS_ENABLE_CUDA ) + #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #else const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif - Kokkos::parallel_for(policy_inst, gc); - } - break; + Kokkos::parallel_for("VBTP3_LoopOverChunks", policy_inst, gc); + } + break; + // Three level parallelism: + // 1. [P] loop over chunks of vertices + // 2. [P] loop over vertices in chunks + // 3. [P] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VBTPVR1: - { + { functorGreedyColorVBTPVR1 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - #if defined( KOKKOS_ENABLE_CUDA ) + #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, chunkSize_, 32); #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 32); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); #endif - Kokkos::parallel_for(policy_inst, gc); - } - break; + Kokkos::parallel_for("VBTPVR1_LoopOverChunks", policy_inst, gc); + } + break; + // Three level parallelism: + // 1. [P] loop over chunks of vertices + // 2. [P] loop over vertices in chunks + // 3. [S] loop over vertex neighbors + // 4. [P] loop over vertex neighbors of neighbors case COLORING_D2_VBTPVR2: - { + { functorGreedyColorVBTPVR2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - #if defined( KOKKOS_ENABLE_CUDA ) + #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, chunkSize_, 32); #else const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); #endif - Kokkos::parallel_for(policy_inst, gc); - } - break; + Kokkos::parallel_for("VBTPVR2_LoopOverChunks", policy_inst, gc); + } + break; default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); - } + } } // colorGreedy (end) @@ -489,16 +514,8 @@ class GraphColorD2 { if(0 == this->_use_color_set) { - functorFindConflicts_Atomic conf(this->nv, - xadj_, - adj_, - t_xadj_, - t_adj_, - vertex_colors_, - current_vertexList_, - next_iteration_recolorList_, - next_iteration_recolorListLength_); - Kokkos::parallel_reduce(my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); + functorFindConflicts_Atomic conf(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, next_iteration_recolorList_, next_iteration_recolorListLength_); + Kokkos::parallel_reduce("FindConflicts", my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); } } else @@ -528,6 +545,7 @@ class GraphColorD2 nnz_lno_temp_work_view_t current_vertexList_, size_type current_vertexListLength_) { + // NOTE: resolveConflicts is SERIAL and thus the forbidden array must be O(V) in size. color_t *forbidden = new color_t[_nv]; nnz_lno_t vid = 0; nnz_lno_t end = _nv; @@ -572,20 +590,20 @@ class GraphColorD2 continue; // loop over distance-1 neighbors of vid - for(size_type vid_1adj = h_idx(vid); vid_1adj < h_idx(vid + 1); vid_1adj++) + for(size_type vid_d1_adj = h_idx(vid); vid_d1_adj < h_idx(vid + 1); vid_d1_adj++) { - size_type vid_1idx = h_adj(vid_1adj); + size_type vid_d1 = h_adj(vid_d1_adj); - // loop over distance-1 neighbors of vid_1idx (distance-2 from vid) - for(size_type vid_2adj = h_t_idx(vid_1idx); vid_2adj < h_t_idx(vid_1idx + 1); vid_2adj++) + // loop over neighbors of vid_d1 (distance-2 from vid) + for(size_type vid_d2_adj = h_t_idx(vid_d1); vid_d2_adj < h_t_idx(vid_d1 + 1); vid_d2_adj++) { - nnz_lno_t vid_2idx = h_t_adj(vid_2adj); + nnz_lno_t vid_d2 = h_t_adj(vid_d2_adj); // skip over loops vid -- x -- vid - if(vid_2idx == vid) + if(vid_d2 == vid) continue; - forbidden[h_colors(vid_2idx)] = vid; + forbidden[h_colors(vid_d2)] = vid; } } @@ -635,9 +653,6 @@ class GraphColorD2 public: - - - // ------------------------------------------------------ // Functors: Distance-2 Graph Coloring // ------------------------------------------------------ @@ -661,7 +676,7 @@ class GraphColorD2 - /** + /** * Functor for VB algorithm speculative coloring without edge filtering. * Single level parallelism */ @@ -678,14 +693,14 @@ class GraphColorD2 nnz_lno_t _chunkSize; // functorGreedyColorVB(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength), _chunkSize(chunkSize) { @@ -742,21 +757,21 @@ class GraphColorD2 } // Check neighbors, fill forbidden array. - for(size_type vid_1adj = _idx(vid); vid_1adj < _idx(vid + 1); vid_1adj++) + for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) { - nnz_lno_t vid_1idx = _adj(vid_1adj); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - for(size_type vid_2adj = _t_idx(vid_1idx); vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { - nnz_lno_t vid_2idx = _t_adj(vid_2adj); + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); // Skip distance-2-self-loops - if(vid_2idx == vid || vid_2idx >= nv) + if(vid_d2 == vid || vid_d2 >= nv) { continue; } - color_t c = _colors(vid_2idx); + const color_t c = _colors(vid_d2); if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { @@ -776,7 +791,7 @@ class GraphColorD2 } } // for c... offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // for offset... + } // while !foundColor } // for ichunk... } // operator() (end) }; // struct functorGreedyColorVB (end) @@ -800,14 +815,14 @@ class GraphColorD2 nnz_lno_t _chunkSize; // functorGreedyColorVBTP(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength), _chunkSize(chunkSize) { @@ -840,7 +855,7 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are addd in the loops over neighbors, then + // - If more levels of parallelism are added in the loops over neighbors, then // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors @@ -873,12 +888,11 @@ class GraphColorD2 // Skip distance-2 self loops if(vid_d2 != vid && vid_d2 < nv) { - color_t c = _colors(vid_d2); + const color_t c = _colors(vid_d2); // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - //Kokkos::atomic_fetch_or(&forbidden[c-offset], true); // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism forbidden[c - offset] = true; } } @@ -901,7 +915,7 @@ class GraphColorD2 } // if chunk_id*... }); // for ichunk... } // operator() (end) - }; // struct functorGreedyColorVBTP (end) + }; // struct functorGreedyColorVBTP (end) @@ -923,23 +937,16 @@ class GraphColorD2 nnz_lno_t _chunkSize; // functorGreedyColorVBTP2(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_) - , _idx(xadj_) - , _adj(adj_) - , _t_idx(t_xadj_) - , _t_adj(t_adj_) - , _colors(colors) - , _vertexList(vertexList) - , _vertexListLength(vertexListLength) - , _chunkSize(chunkSize) + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) { } @@ -971,7 +978,7 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are addd in the loops over neighbors, then + // - If more levels of parallelism are added in the loops over neighbors, then // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors @@ -992,11 +999,11 @@ class GraphColorD2 } // Loop over neighbors - //for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + // for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { - size_type vid_d1_adj = idx + _idx(vid); - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_d1_adj = _idx(vid) + idx; + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); // Loop over distance-2 neighbors for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) @@ -1006,18 +1013,19 @@ class GraphColorD2 // Skip distance-2 self loops if(vid_d2 != vid && vid_d2 < nv) { - color_t c = _colors(vid_d2); + const color_t c = _colors(vid_d2); // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } } }); + thread.team_barrier(); + // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) { @@ -1056,23 +1064,16 @@ class GraphColorD2 nnz_lno_t _chunkSize; // functorGreedyColorVBTP3(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_) - , _idx(xadj_) - , _adj(adj_) - , _t_idx(t_xadj_) - , _t_adj(t_adj_) - , _colors(colors) - , _vertexList(vertexList) - , _vertexListLength(vertexListLength) - , _chunkSize(chunkSize) + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) { } @@ -1104,7 +1105,7 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are addd in the loops over neighbors, then + // - If more levels of parallelism are added in the loops over neighbors, then // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors @@ -1132,18 +1133,17 @@ class GraphColorD2 // Loop over distance-2 neighbors Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) { - size_type vid_d2_adj = idx + _t_idx(vid_d1); - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + const size_type vid_d2_adj = _t_idx(vid_d1) + idx; + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); // Skip distance-2 self loops if(vid_d2 != vid && vid_d2 < nv) { - color_t c = _colors(vid_d2); + const color_t c = _colors(vid_d2); // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - // WCMCLEN SCAFFOLDING - For VectorLevel Parallelism Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } @@ -1173,7 +1173,7 @@ class GraphColorD2 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop over chunks - * Vector Range Enabled on loop over neighbors of neighbors TODO: Make it so! + * Vector Range Enabled on loop over neighbors of neighbors */ struct functorGreedyColorVBTPVR1 { @@ -1228,7 +1228,7 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are addd in the loops over neighbors, then + // - If more levels of parallelism are added in the loops over neighbors, then // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors @@ -1249,9 +1249,12 @@ class GraphColorD2 } // Loop over neighbors - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) { - size_type vid_d1_adj = idx + _idx(vid); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) + { + //size_type vid_d1_adj = idx + _idx(vid); + const size_type vid_d1_adj = _idx(vid) + idx; const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + // Loop over distance-2 neighbors for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { @@ -1260,18 +1263,19 @@ class GraphColorD2 // Skip distance-2 self loops if(vid_d2 != vid && vid_d2 < nv) { - color_t c = _colors(vid_d2); + const color_t c = _colors(vid_d2); // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - // WCMCLEN SCAFFOLDING - For VectorLevel Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } } }); + thread.team_barrier(); + // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) { @@ -1351,7 +1355,7 @@ class GraphColorD2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are addd in the loops over neighbors, then + // - If more levels of parallelism are added in the loops over neighbors, then // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors @@ -1371,30 +1375,32 @@ class GraphColorD2 forbidden[0] = true; } - // Check neighbors, fill forbidden array. + // Check neighbors, fill forbidden array. for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) { - nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); // Loop over distance-2 neighbors - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _t_idx(vid_d1+1) - _t_idx(vid_d1)), [&](const size_type &idx) { - const size_type vid_d2_adj = idx + _t_idx(vid); - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) + { + //const size_type vid_d2_adj = idx + _t_idx(vid); + const size_type vid_d2_adj = _t_idx(vid_d1) + idx; + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); // Skip distance-2 self loops if(vid_d2 != vid && vid_d2 < nv) { - color_t c = _colors(vid_d2); + const color_t c = _colors(vid_d2); // If color found is inside current 'range' then mark it as used. if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - // WCMCLEN SCAFFOLDING - For VectorLevel Kokkos::atomic_fetch_or(&forbidden[c - offset], true); } } - }); // for vid_d2_adj... - } // for vid_d1_adj... + }); // for vid_d2_adj... + thread.team_barrier(); + } // for vid_d1_adj... // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) @@ -1451,9 +1457,9 @@ class GraphColorD2 { typedef typename std::remove_reference::type atomic_incr_type; const nnz_lno_t vid = _vertexList(vid_); - color_t my_color = _colors(vid); + color_t my_color = _colors(vid); - size_type vid_1adj = _idx(vid); + size_type vid_1adj = _idx(vid); const size_type vid_1adj_end = _idx(vid + 1); bool break_out = false; From 35d43709830da7f0ceff3ca8d6ae29a16b856f57 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 19 Jun 2018 19:36:31 -0600 Subject: [PATCH 032/190] Adding COLORING_D2_VB_BIT (initial) - Distance-2 colorng validation - Distance-2 coloring VBBIT style variant. - Edge filtering currently off - This fails on vanHeukelum/cage15 mesh, tracking the bug is WIP. --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 152 ++- src/graph/KokkosGraph_Distance2Color.hpp | 70 +- src/graph/KokkosGraph_GraphColor.hpp | 6 +- src/graph/KokkosGraph_GraphColorHandle.hpp | 17 +- ...raph_Distance2Color_MatrixSquared_impl.hpp | 31 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 990 +++++++++++++++--- .../impl/KokkosGraph_GraphColor_impl.hpp | 40 +- 7 files changed, 1115 insertions(+), 191 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 93c0b3445a..5e39d7c568 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -44,6 +44,7 @@ // EXERCISE 1 Goal: // Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. #include +#include #include #include @@ -221,6 +222,21 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 8; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT")) + { + params.algorithm = 9; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT_EF")) + { + params.algorithm = 10; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP_BIT")) + { + params.algorithm = 11; + got_required_param_algorithm = true; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -351,6 +367,18 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_SERIAL); label_algorithm = "COLORING_D2_SERIAL"; break; + case 9: + kh.create_graph_coloring_handle(COLORING_D2_VB_BIT); + label_algorithm = "COLORING_D2_VB_BIT"; + break; + case 10: + kh.create_graph_coloring_handle(COLORING_D2_VB_BIT_EF); + label_algorithm = "COLORING_D2_VB_BIT_EF"; + break; + case 11: + kh.create_graph_coloring_handle(COLORING_D2_VBTP_BIT); + label_algorithm = "COLORING_D2_VBTP_BIT"; + break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; @@ -359,12 +387,18 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << ">>> Run Graph Color D2 (" << label_algorithm << ")" << std::endl; + // If any of the runs have an invalid result, this will be set to false. + bool all_results_valid = true; + // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + total_colors += kh.get_graph_coloring_handle()->get_num_colors(); + total_phases += kh.get_graph_coloring_handle()->get_num_phases(); + std::cout << "Total Time: " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; @@ -372,6 +406,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; + // If verbose mode is on and there the graph has fewer than 1000 verts, dump a GraphVIZ DOT file. if(verbose && repeat==i+1 && crsGraph.numRows() < 1000) { auto colors = kh.get_graph_coloring_handle()->get_vertex_colors(); @@ -383,21 +418,65 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) colors); } - total_colors += kh.get_graph_coloring_handle()->get_num_colors(); - total_phases += kh.get_graph_coloring_handle()->get_num_phases(); - } + // ------------------------------------------ + // Verify correctness + // ------------------------------------------ + bool d2_coloring_is_valid = false; + bool d2_coloring_validation_flags[4] = {false}; + + d2_coloring_is_valid = verifyDistance2Coloring(&kh, + crsGraph.numRows(), + crsGraph.numCols(), + crsGraph.row_map, + crsGraph.entries, + crsGraph.row_map, + crsGraph.entries, + d2_coloring_validation_flags); + + // Print out messages based on coloring validation check. + if(d2_coloring_is_valid) + { + std::cout << std::endl << ">>> Distance-2 Graph Coloring is VALID" << std::endl << std::endl; + } + else + { + all_results_valid = false; + std::cout << std::endl + << ">>> Distance-2 Graph Coloring is NOT VALID" << std::endl + << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl + << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl + << std::endl; + } + if(d2_coloring_validation_flags[3]) + { + std::cout << ">>> Distance-2 Graph Coloring may have poor quality." << std::endl + << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl + << std::endl; + } - double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); - double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); - double total_time_find_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); - double total_time_resolve_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); + // ------------------------------------------ + // Print out the colors histogram + // ------------------------------------------ + printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); - double avg_time = total_time / repeat; - double avg_time_color_greedy = total_time_color_greedy / repeat; - double avg_time_find_conflicts = total_time_find_conflicts / repeat; - double avg_time_resolve_conflicts = total_time_resolve_conflicts / repeat; + } // for i... + + + double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); + double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); + double total_time_find_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); + double total_time_resolve_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); + double total_time_matrix_squared = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase4(); + double total_time_matrix_squared_d1 = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase5(); + + double avg_time = total_time / (double)repeat; + double avg_time_color_greedy = total_time_color_greedy / (double)repeat; + double avg_time_find_conflicts = total_time_find_conflicts / (double)repeat; + double avg_time_resolve_conflicts = total_time_resolve_conflicts / (double)repeat; double avg_colors = total_colors / (double)repeat; double avg_phases = total_phases / (double)repeat; + double avg_time_matrix_squared = total_time_matrix_squared / (double)repeat; + double avg_time_matrix_squared_d1 = total_time_matrix_squared_d1 / (double)repeat; std::string a_mtx_bin_file = params.a_mtx_bin_file; a_mtx_bin_file = a_mtx_bin_file.substr(a_mtx_bin_file.find_last_of("/\\") + 1); @@ -419,21 +498,32 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) perror("getlogin_r"); } - - std::cout << "Summary:" << std::endl - << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl - << " Filename : " << a_mtx_bin_file << std::endl - << " Num Verts : " << crsGraph.numRows() << std::endl - << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl - << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl - << " Algorithm : " << label_algorithm << std::endl - << " Total Time : " << total_time << std::endl - << " Avg Time : " << avg_time << std::endl - << " Avg Time CG : " << avg_time_color_greedy << std::endl - << " Avg Time FC : " << avg_time_find_conflicts << std::endl - << " Avg Time RC : " << avg_time_resolve_conflicts << std::endl - << " Avg colors : " << avg_colors << std::endl - << " Avg Phases : " << avg_phases << std::endl + std::string all_results_valid_str = "PASSED"; + if(!all_results_valid) + all_results_valid_str = "FAILED"; + + std::cout << "Summary" << std::endl + << "-------" << std::endl + << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl + << " Filename : " << a_mtx_bin_file << std::endl + << " Num Verts : " << crsGraph.numRows() << std::endl + << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl + << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl + << " Algorithm : " << label_algorithm << std::endl + << "Overall Time/Stats" << std::endl + << " Total Time : " << total_time << std::endl + << " Avg Time : " << avg_time << std::endl + << "VB Distance[1|2] Stats " << std::endl + << " Avg Time CG : " << avg_time_color_greedy << std::endl + << " Avg Time FC : " << avg_time_find_conflicts << std::endl + << " Avg Time RC : " << avg_time_resolve_conflicts << std::endl + << "Matrix-Squared + D1 Stats" << std::endl + << " Avg Time to M^2: " << avg_time_matrix_squared << std::endl + << " Avg Time to D1 : " << avg_time_matrix_squared_d1 << std::endl + << "Coloring Stats" << std::endl + << " Avg colors : " << avg_colors << std::endl + << " Avg Phases : " << avg_phases << std::endl + << " Validation : " << all_results_valid_str << std::endl << std::endl; std::cout << "CSVHDR" @@ -442,15 +532,18 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" - << "," << "Concurrency" << "," << "Algorithm" + << "," << "Concurrency" << "," << "Repetitions" << "," << "Total Time" + << "," << "Total Time to M^2" + << "," << "Total Time D1(M^2)" << "," << "Total Time CG" << "," << "Total Time FC" << "," << "Total Time RC" << "," << "Avg Colors" << "," << "Avg Num Phases" + << "," << "Validation" << std::endl; std::cout << "CSVDATA" @@ -459,15 +552,18 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() - << "," << Kokkos::DefaultExecutionSpace::concurrency() << "," << label_algorithm + << "," << Kokkos::DefaultExecutionSpace::concurrency() << "," << repeat << "," << total_time + << "," << total_time_matrix_squared + << "," << total_time_matrix_squared_d1 << "," << total_time_color_greedy << "," << total_time_find_conflicts << "," << total_time_resolve_conflicts << "," << avg_colors << "," << avg_phases + << "," << all_results_valid_str << std::endl; // Kokkos::print_configuration(std::cout); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 471304d438..bd0d7b8dbb 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -54,8 +54,9 @@ namespace KokkosGraph{ namespace Experimental{ - -// initial distance 2 graph coloring -- serial only (work in progress) - wcmclen +/** + * Distance 2 Graph Coloring + */ template void graph_color_d2(KernelHandle *handle, typename KernelHandle::nnz_lno_t num_rows, @@ -113,7 +114,10 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2: case COLORING_D2_VB: + case COLORING_D2_VB_BIT: + case COLORING_D2_VB_BIT_EF: case COLORING_D2_VBTP: + case COLORING_D2_VBTP_BIT: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: case COLORING_D2_VBTPVR1: @@ -136,6 +140,68 @@ void graph_color_d2(KernelHandle *handle, gch->set_coloring_time(coloring_time); } + + +/** + * Validate Distance 2 Graph Coloring + * + * @param validation_flags is an array of 4 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. + * May not be an INVALID coloring, but can indicate poor quality in coloring. + * + * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. + */ +template +bool verifyDistance2Coloring(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + bool validation_flags[]) +{ + bool output = true; + + typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); + + Impl::GraphColorD2 gc( + num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + + output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch->get_vertex_colors(), validation_flags); + + return output; +} + + + +/** + * Print out a histogram of graph colors for Distance-2 Graph Coloring + */ +template +void printDistance2ColorsHistogram(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries) +{ + Impl::GraphColorD2 gc( + num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + + gc.printDistance2ColorsHistogram(); +} + + + + } // end namespace Experimental } // end namespace KokkosGraph diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_GraphColor.hpp index ca61c85a2b..f774f1b265 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_GraphColor.hpp @@ -72,6 +72,8 @@ void graph_color_symbolic( typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; + gch->set_tictoc(handle->get_verbose()); + color_view_type colors_out = color_view_type("Graph Colors", num_rows); @@ -102,7 +104,7 @@ void graph_color_symbolic( typedef typename Impl::GraphColor_EB EBGraphColoring; gc = new EBGraphColoring(num_rows, entries.extent(0),row_map, entries, gch); break; - + case COLORING_SPGEMM: case COLORING_D2_MATRIX_SQUARED: //std::cout << ">>> WCMCLEN graph_color_symbolic (KokkosGraph_graph_color.hpp) [ COLORING_SPGEMM / COLORING_D2_MATRIX_SQUARED ]" << std::endl; @@ -202,7 +204,7 @@ void d2_graph_color( case COLORING_SERIAL2: // WCMCLEN: for now we don't need to worry about this optimization. { color_view_type colors_out = color_view_type("Graph Colors", num_rows); - Impl::GraphColor2 + Impl::GraphColor2 gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); gch->set_num_phases(num_phases); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 7c3e697c98..88f8a218a9 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -65,7 +65,10 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) COLORING_D2, // Distance-2 Graph Coloring COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based + COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT + COLORING_D2_VB_BIT_EF, // Distance-2 Graph Coloring Vertex Based BIT + Edge Filtering COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy + COLORING_D2_VBTP_BIT, // Distance-2 Graph Coloring Vertex Based BIT w/ Team Policy COLORING_D2_VBTP2, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 2) COLORING_D2_VBTP3, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) COLORING_D2_VBTPVR1, // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 1) @@ -150,9 +153,10 @@ class GraphColoringHandle //STATISTICS double overall_coloring_time; //the overall time that it took to color the graph. In the case of the iterative calls. double overall_coloring_time_phase1; // - double overall_coloring_time_phase2; // Some detailed timer accumulators for (generic) internal phases - double overall_coloring_time_phase3; // + double overall_coloring_time_phase2; // + double overall_coloring_time_phase3; // Some timer accumulators for internal phases. double overall_coloring_time_phase4; // + double overall_coloring_time_phase5; // double coloring_time; //the time that it took to color the graph int num_phases; // @@ -184,12 +188,14 @@ class GraphColoringHandle tictoc(false), vb_edge_filtering(false), vb_chunk_size(8), - max_number_of_iterations(200), eb_num_initial_colors(1), + max_number_of_iterations(50), // WCMCLEN SCAFFOLDING Change back to default = 200 + eb_num_initial_colors(1), overall_coloring_time(0), overall_coloring_time_phase1(0), overall_coloring_time_phase2(0), overall_coloring_time_phase3(0), overall_coloring_time_phase4(0), + overall_coloring_time_phase5(0), coloring_time(0), num_phases(0), size_of_edge_list(0), lower_triangle_src(), lower_triangle_dst(), vertex_colors(), is_coloring_called_before(false), num_colors(0) @@ -621,7 +627,10 @@ class GraphColoringHandle case COLORING_D2_SERIAL: case COLORING_D2: case COLORING_D2_VB: + case COLORING_D2_VB_BIT: + case COLORING_D2_VB_BIT_EF: case COLORING_D2_VBTP: + case COLORING_D2_VBTP_BIT: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: case COLORING_D2_VBTPVR1: @@ -673,6 +682,7 @@ class GraphColoringHandle double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } + double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } double get_coloring_time() const { return this->coloring_time;} int get_num_phases() const { return this->num_phases;} color_view_t get_vertex_colors() const {return this->vertex_colors;} @@ -693,6 +703,7 @@ class GraphColoringHandle void add_to_overall_coloring_time_phase2(const double &coloring_time_){this->overall_coloring_time_phase2 += coloring_time_;} void add_to_overall_coloring_time_phase3(const double &coloring_time_){this->overall_coloring_time_phase3 += coloring_time_;} void add_to_overall_coloring_time_phase4(const double &coloring_time_){this->overall_coloring_time_phase4 += coloring_time_;} + void add_to_overall_coloring_time_phase5(const double &coloring_time_){this->overall_coloring_time_phase5 += coloring_time_;} void set_coloring_time(const double &coloring_time_){this->coloring_time = coloring_time_;} void set_num_phases(const double &num_phases_){this->num_phases = num_phases_;} void set_vertex_colors( const color_view_t vertex_colors_){ diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 0862cce7f3..02495fb1b8 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -61,10 +61,6 @@ namespace KokkosGraph { namespace Impl { -#define VB_D2_COLORING_FORBIDDEN_SIZE 64 -// #define VB_D2_COLORING_FORBIDDEN_SIZE 20000 - - /*! \brief Base class for graph coloring purposes. * Each color represents the set of the vertices that are independent, @@ -118,6 +114,8 @@ class GraphColorD2_MatrixSquared nnz_lno_t nv; // num vertices HandleType *cp; // the handle. + bool verbose; + public: /** * \brief GraphColor constructor. @@ -137,7 +135,7 @@ class GraphColorD2_MatrixSquared const_clno_row_view_t t_row_map, const_clno_nnz_view_t t_entries, HandleType *handle) - : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle) + : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle), verbose(handle->get_verbose()) { } @@ -159,6 +157,10 @@ class GraphColorD2_MatrixSquared */ virtual void execute() { + double time = 0; + Kokkos::Impl::Timer timer; + timer.reset(); + std::string algName = "SPGEMM_KK_MEMSPEED"; cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); @@ -179,8 +181,15 @@ class GraphColorD2_MatrixSquared scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); // Run the numeric kernel - KokkosSparse::Experimental::spgemm_numeric( - cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); + KokkosSparse::Experimental::spgemm_numeric(cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); + + if(this->verbose) + { + time = timer.seconds(); + std::cout << "\tTime Phase Square Matrix : " << time << std::endl << std::endl; + this->cp->get_graph_coloring_handle()->add_to_overall_coloring_time_phase4(time); + timer.reset(); + } // done with spgemm cp->destroy_spgemm_handle(); @@ -189,6 +198,14 @@ class GraphColorD2_MatrixSquared // Use LocalOrdinal for storing colors KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); + if(this->verbose) + { + time = timer.seconds(); + std::cout << "\tTime Phase Graph Coloring : " << time << std::endl << std::endl; + this->cp->get_graph_coloring_handle()->add_to_overall_coloring_time_phase5(time); + timer.reset(); + } + // extract the colors // auto coloringHandle = cp->get_graph_coloring_handle(); // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 56189ca784..2bb9ecdcee 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -62,16 +62,14 @@ namespace KokkosGraph { namespace Impl { -#define VB_D2_COLORING_FORBIDDEN_SIZE 64 -// #define VB_D2_COLORING_FORBIDDEN_SIZE 20000 - - +#define VB_D2_COLORING_FORBIDDEN_SIZE 64 +#define VBBIT_D2_COLORING_FORBIDDEN_SIZE 64 /*! - * \brief Base class for graph coloring purposes. - * Each color represents the set of the vertices that are independent, - * e.g. no vertex having same color shares an edge. - * General aim is to find the minimum number of colors, minimum number of independent sets. + * \brief Distance-2 Graph Coloring class + * + * This class supports direct methods for distance-2 graph coloring. + * */ template class GraphColorD2 @@ -111,8 +109,12 @@ class GraphColorD2 typedef Kokkos::TeamPolicy team_policy_t; typedef typename team_policy_t::member_type team_member_t; + typedef Kokkos::View non_const_1d_bool_view_t; + + typedef long long int bit_64_forbidden_t; protected: + nnz_lno_t nv; // num vertices nnz_lno_t nr; // num_rows (# verts) nnz_lno_t nc; // num cols @@ -125,14 +127,15 @@ class GraphColorD2 typename HandleType::GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle private: + int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs int _max_num_iterations; char _conflictList; // 0: none, 1: atomic (default), 2: parallel prefix sums (0, 2 not implemented) - bool _serialConflictResolution; // true if using serial conflict resolution, false otherwise (default) char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). bool _ticToc; // if true print info in each step public: + /** * \brief GraphColor constructor. * \param nv_: number of vertices in the graph @@ -153,11 +156,8 @@ class GraphColorD2 : nv(nv_), nr(nv_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1), - _serialConflictResolution(false), _use_color_set(0), _ticToc(handle->get_verbose()) + _use_color_set(0), _ticToc(handle->get_verbose()) { - // std::cout << ">>> WCMCLEN GraphColorD2() (KokkosGraph_Distance2Color_impl.hpp)" << std::endl - // << ">>> WCMCLEN : coloring_algo_type = " << handle->get_coloring_algo_type() << std::endl - // << ">>> WCMCLEN : conflict_list_type = " << handle->get_conflict_list_type() << std::endl; } @@ -174,8 +174,21 @@ class GraphColorD2 // ----------------------------------------------------------------- virtual void execute() { + bool using_edge_filtering = false; + color_view_type colors_out("Graph Colors", this->nv); + // If the selected pass is using edge filtering we should set the flag. + switch(this->gc_handle->get_coloring_algo_type()) + { + case COLORING_D2_VB_BIT_EF: + using_edge_filtering = true; + break; + default: + break; + } + + // Data: // gc_handle = graph coloring handle // nr = num_rows (scalar) @@ -189,16 +202,16 @@ class GraphColorD2 << "\t useConflictList : " << (int)this->_conflictList << std::endl << "\t ticToc : " << this->_ticToc << std::endl << "\t max_num_iterations : " << this->_max_num_iterations << std::endl - << "\t serialConflictResolution : " << (int)this->_serialConflictResolution << std::endl << "\t chunkSize : " << this->_chunkSize << std::endl << "\t use_color_set : " << (int)this->_use_color_set << std::endl + << "\t Edge Filtering Pass? : " << (int)using_edge_filtering << std::endl << "\tgraph information:" << std::endl << "\t nv : " << this->nv << std::endl << "\t ne : " << this->ne << std::endl; - } - // prettyPrint1DView(this->xadj, ">>> WCMCLEN xadj ", 500); - // prettyPrint1DView(this->adj, ">>> WCMCLEN adj ", 500); + // prettyPrint1DView(this->xadj, ">>> xadj ", 500); + // prettyPrint1DView(this->adj, ">>> adj ", 500); + } // conflictlist - store conflicts that can happen when we're coloring in parallel. nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); @@ -222,22 +235,35 @@ class GraphColorD2 nnz_lno_t numUncolored = this->nv; nnz_lno_t current_vertexListLength = this->nv; - nnz_lno_t previous_vertexListLength = this->nv; double time; double total_time = 0.0; Kokkos::Impl::Timer timer; - // make sure the timer resets, just in case - timer.reset(); - int iter = 0; for(; (iter < _max_num_iterations) && (numUncolored > 0); iter++) { + timer.reset(); + // ------------------------------------------ // Do greedy color // ------------------------------------------ - this->colorGreedy(this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + if(using_edge_filtering) + { + // Temp copy of the adj array (mutable) + // - This is required for edge-filtering passes to avoid + // side effects since edge filtering modifies the adj array. + nnz_lno_temp_work_view_t adj_copy; + + adj_copy = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("adj copy"), this->ne); + Kokkos::deep_copy(adj_copy, this->adj); + + this->colorGreedyEF(this->xadj, adj_copy, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + } + else + { + this->colorGreedy(this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + } MyExecSpace::fence(); @@ -246,17 +272,14 @@ class GraphColorD2 time = timer.seconds(); total_time += time; std::cout << "\tIteration: " << iter << std::endl - << "\t - Time speculative greedy phase : " << time << std::endl - << "\t - num 'active' vertices : " << current_vertexListLength << " (" << current_vertexListLength - previous_vertexListLength << ")" << std::endl; + << "\t - Time speculative greedy phase : " << time << std::endl; + // << "\t - Num Uncolored : " << numUncolored << std::endl; - previous_vertexListLength = current_vertexListLength; + gc_handle->add_to_overall_coloring_time_phase1(time); timer.reset(); - gc_handle->add_to_overall_coloring_time_phase1(time); } - // prettyPrint1DView(colors_out, ">>> WCMCLEN colors_out", 100); - // ------------------------------------------ // Find conflicts // ------------------------------------------ @@ -282,8 +305,8 @@ class GraphColorD2 time = timer.seconds(); total_time += time; std::cout << "\t - Time conflict detection " << " : " << time << std::endl; - timer.reset(); gc_handle->add_to_overall_coloring_time_phase2(time); + timer.reset(); } // If conflictList is used and we need to swap the work arrays @@ -303,11 +326,11 @@ class GraphColorD2 } // end for iter... // ------------------------------------------ - // clean up in serial (resolveConflicts) + // clean up in serial (resolveConflictsSerial) // ------------------------------------------ if(numUncolored > 0) { - this->resolveConflicts(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + this->resolveConflictsSerial(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } MyExecSpace::fence(); @@ -320,14 +343,105 @@ class GraphColorD2 gc_handle->add_to_overall_coloring_time_phase3(time); } - // Save out the number of phases and vertex colors + // Save the number of phases and vertex colors to the graph coloring handle this->gc_handle->set_vertex_colors(colors_out); this->gc_handle->set_num_phases((double)iter); + // ------------------------------------------ + // Print out histogram of colors + // ------------------------------------------ + if(_ticToc) + { + //prettyPrint1DView(colors_out, ">>> colors_out ", 500); // WCMCLEN + //printDistance2ColorsHistogram(); + } } // color_graph_d2 (end) + /** + * Validate Distance 2 Graph Coloring + * + * @param validation_flags is an array of 3 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. + * This may not be an INVALID coloring, but can indicate poor quality in coloring. + * + * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. + */ + bool verifyDistance2Coloring(const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + bool validation_flags[]) + { + bool output = true; + + validation_flags[0] = false; // True if an invalid coloring. + validation_flags[1] = false; // True if uncolored vertices exist. + validation_flags[2] = false; // True if an invalid color exists. + + nnz_lno_t chunkSize_ = this->_chunkSize; + if(nv < 100 * chunkSize_) + { + chunkSize_ = 1; + } + const size_t num_chunks = this->nv / chunkSize_ + 1; + + non_const_1d_bool_view_t d_flags("flags", 4); + + // Create host mirror view. + non_const_1d_bool_view_t::HostMirror h_flags = Kokkos::create_mirror_view(d_flags); + + // Initialize flags on host + for(int i = 0; i < 4; i++) h_flags(i) = false; + + // Deep copy initialized flags to device + Kokkos::deep_copy(d_flags, h_flags); + + functorVerifyDistance2Coloring vr(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, d_flags, chunkSize_); + Kokkos::parallel_for("ValidateD2Coloring", my_exec_space(0, num_chunks), vr); + + // Deep copy flags back to host memory + Kokkos::deep_copy(h_flags, d_flags); + + validation_flags[0] = h_flags[0]; + validation_flags[1] = h_flags[1]; + validation_flags[2] = h_flags[2]; + validation_flags[3] = h_flags[3]; + + output = !h_flags[0]; + + return output; + } // verifyDistance2Coloring (end) + + + + /** + * Print out the distance-2 coloring histogram. + */ + void printDistance2ColorsHistogram(void) + { + nnz_lno_t num_colors = this->gc_handle->get_num_colors(); + std::cout << "num_colors: " << num_colors << std::endl; + + nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); + MyExecSpace::fence(); + KokkosKernels::Impl::kk_get_histogram( + this->nv, this->gc_handle->get_vertex_colors(), histogram); + + std::cout << ">>> Histogram: " << std::endl; + KokkosKernels::Impl::kk_print_1Dview(histogram); + std::cout << std::endl; + } + + + + private: // ----------------------------------------------------------------- // @@ -363,7 +477,7 @@ class GraphColorD2 case COLORING_D2_VB: { functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for("VB_LoopOverChunks", my_exec_space(0, num_chunks), gc); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); } break; @@ -379,10 +493,11 @@ class GraphColorD2 #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, chunkSize_); #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); + //const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); + const team_policy_t policy_inst(num_chunks, chunkSize_); #endif - Kokkos::parallel_for("VBTP_LoopOverChunks", policy_inst, gc); + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; @@ -401,7 +516,7 @@ class GraphColorD2 const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif - Kokkos::parallel_for("VBTP2_LoopOverChunks", policy_inst, gc); + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; @@ -420,7 +535,7 @@ class GraphColorD2 const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif - Kokkos::parallel_for("VBTP3_LoopOverChunks", policy_inst, gc); + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; @@ -439,15 +554,16 @@ class GraphColorD2 const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); #endif - Kokkos::parallel_for("VBTPVR1_LoopOverChunks", policy_inst, gc); + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; // Three level parallelism: // 1. [P] loop over chunks of vertices // 2. [P] loop over vertices in chunks - // 3. [S] loop over vertex neighbors - // 4. [P] loop over vertex neighbors of neighbors + // 3. [S] loop over color offset blocks + // 4. [S] loop over vertex neighbors + // 5. [P] loop over vertex neighbors of neighbors case COLORING_D2_VBTPVR2: { functorGreedyColorVBTPVR2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); @@ -458,24 +574,102 @@ class GraphColorD2 const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); #endif - Kokkos::parallel_for("VBTPVR2_LoopOverChunks", policy_inst, gc); + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); + } + break; + + // One level Perallelism, BIT Array for coloring + // 1. [P] loop over chunks of vertices + // 2. [S] loop over vertices in chunks + // 3. [S] loop over color offset blocks + // 4. [S] loop over vertex neighbors + // 5. [S] loop over vertex neighbors of neighbors + case COLORING_D2_VB_BIT: + { + functorGreedyColorVB_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); + } + break; + + // Two level Perallelism, BIT Array for coloring + // 1. [P] loop over chunks of vertices + // 2. [P] loop over vertices in chunks + // 3. [S] loop over color offset blocks + // 4. [S] loop over vertex neighbors + // 5. [S] loop over vertex neighbors of neighbors + case COLORING_D2_VBTP_BIT: + { + functorGreedyColorVBTP_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + + #if defined(KOKKOS_ENABLE_CUDA) + const team_policy_t policy_inst(num_chunks, chunkSize_); + #else + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); + #endif + + Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; default: - throw std::invalid_argument("Unknown Distance-2 Algorithm Type"); + throw std::invalid_argument("Unknown Distance-2 Algorithm Type or invalid for non Edge Filtering mode."); } } // colorGreedy (end) + // ----------------------------------------------------------------- + // + // GraphColorD2::colorGreedyEF() + // + // ----------------------------------------------------------------- + void colorGreedyEF(const_lno_row_view_t xadj_, + nnz_lno_temp_work_view_t adj_copy_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + nnz_lno_t current_vertexListLength_) + { + nnz_lno_t chunkSize_ = this->_chunkSize; + + if(current_vertexListLength_ < 100 * chunkSize_) + { + chunkSize_ = 1; + } + + const size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; + + // Pick the right coloring algorithm to use based on which algorithm we're using + switch(this->gc_handle->get_coloring_algo_type()) + { + // One level Perallelism, BIT Array for coloring + edge filtering + // 1. [P] loop over chunks of vertices + // 2. [S] loop over vertices in chunks + // 3. [S] loop over color offset blocks + // 4. [S] loop over vertex neighbors + // 5. [S] loop over vertex neighbors of neighbors + case COLORING_D2_VB_BIT_EF: + { + functorGreedyColorVB_BIT_EF gc(this->nv, xadj_, adj_copy_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); + //prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); + } + break; + + default: + throw std::invalid_argument("Unknown Distance-2 Algorithm Type or algorithm does not use Edge Filtering."); + } + } // colorGreedyEF (end) + + + // ----------------------------------------------------------------- // // GraphColorD2::findConflicts() // // ----------------------------------------------------------------- - // NOTE: not using colorset algorithm in this so we don't include colorset data template nnz_lno_t findConflicts(bool &swap_work_arrays, const_lno_row_view_t xadj_, @@ -532,11 +726,11 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::resolveConflicts() + // GraphColorD2::resolveConflictsSerial() // // ----------------------------------------------------------------- template - void resolveConflicts(nnz_lno_t _nv, + void resolveConflictsSerial(nnz_lno_t _nv, const_lno_row_view_t xadj_, adj_view_t adj_, const_clno_row_view_t t_xadj_, @@ -545,7 +739,6 @@ class GraphColorD2 nnz_lno_temp_work_view_t current_vertexList_, size_type current_vertexListLength_) { - // NOTE: resolveConflicts is SERIAL and thus the forbidden array must be O(V) in size. color_t *forbidden = new color_t[_nv]; nnz_lno_t vid = 0; nnz_lno_t end = _nv; @@ -615,7 +808,7 @@ class GraphColorD2 } Kokkos::deep_copy(vertex_colors_, h_colors); delete[] forbidden; - } // resolveConflicts (end) + } // resolveConflictsSerial (end) // ------------------------------------------------------ @@ -718,83 +911,517 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const nnz_lno_t vid_) const { - // std::cout << ">>> WCMCLEN functorGreedyColor::operator()(" << vid_ << ") (KokkosGraph_Distance2Color_impl.hpp)" << std::endl; - nnz_lno_t vid = 0; for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) { if(vid_ * _chunkSize + ichunk < _vertexListLength) - vid = _vertexList(vid_ * _chunkSize + ichunk); - else - continue; - - // Already colored this vertex. - if(_colors(vid) > 0) { - continue; - } + const nnz_lno_t vid = _vertexList(vid_ * _chunkSize + ichunk); + + // If vertex is not already colored... + if(_colors(vid) <= 0) + { + bool foundColor = false; // Have we found a valid color? + + const size_type vid_adj_begin = _idx(vid); + const size_type vid_adj_end = _idx(vid + 1); + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the forbidden array is too small. + // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations + // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. + // This could be as big as all the vertices in the graph if diameter(G)=2... + // * TODO: Determine if we can cap this at something lower than nv. + for(color_t offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) + { + // initialize + for(int i = 0; i < VB_D2_COLORING_FORBIDDEN_SIZE; i++) { forbidden[i] = false; } + + // Colors start at 1. 0 is special in that it means a vertex is uncolored. + // For the range 0..63 we mark forbidden[0] as true to take color 0 out of + // consideration. + if(0 == offset) + { + forbidden[0] = true; + } + + // Check neighbors, fill forbidden array. + for(size_type vid_adj = vid_adj_begin; vid_adj < vid_adj_end; vid_adj++) + { + const nnz_lno_t vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + + for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + + // Skip distance-2-self-loops + if(vid_d2 != vid && vid_d2 < nv) + { + const color_t c = _colors(vid_d2); + + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + { + forbidden[c - offset] = true; + } + } + } // for vid_d1_adj... + } // for vid_adj... - bool foundColor = false; // Have we found a valid color? + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + } // for !foundColor... + } // if _colors(vid) <= 0... + } // if vid_ * _chunkSize... + } // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVB (end) + + + + /** + * Functor for VB_BIT algorithm coloring without edge filtering. + * Single level parallelism + */ + struct functorGreedyColorVB_BIT + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + functorGreedyColorVB_BIT(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } - // Do multiple passes if the array is too small. - // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. - // This could be as big as all the vertices in the graph if diameter(G)=2... - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - while(!foundColor) + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t vid_) const + { + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + if(vid_ * _chunkSize + ichunk < _vertexListLength) { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - // by convention, start at 1 - if(offset == 0) - { - forbidden[0] = true; - } + const nnz_lno_t vid = _vertexList(vid_ * _chunkSize + ichunk); - // Check neighbors, fill forbidden array. - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) + // If vertex is not colored yet... + if(_colors(vid) == 0) { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_adj_begin = _idx(vid); + const size_type vid_adj_end = _idx(vid + 1); - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) + bool foundColor = false; + for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + // Forbidden colors + // - single long int for forbidden colors + bit_64_forbidden_t forbidden = 0; + + // If all available colors for this range are unavailable we can break out of the nested loops + bool break_out = false; - // Skip distance-2-self-loops - if(vid_d2 == vid || vid_d2 >= nv) + // Loop over distance-1 neighbors of vid + for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) { - continue; + const nnz_lno_t vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + + // Loop over distance-2 neighbors of vid + for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + + // Ignore Distance-2 Self Loops + if(vid_d2 != vid && vid_d2 < nv) + { + const color_t color = _colors(vid_d2); + const color_t color_offset = color - offset; + + // if color is within the current range, or if its color is in a previously traversed + // range + if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) + { + // if it is in the current range, then add the color to the banned colors + if(color > offset) + { + // convert color to bit representation + bit_64_forbidden_t ban_color_bit = 1; + + ban_color_bit = ban_color_bit << (color_offset - 1); + + // add it to forbidden colors + forbidden = forbidden | ban_color_bit; + + // if there are no available colors in this range then exit early, + // no need to traverse the rest. + if(0 == ~forbidden) + { + break_out = true; + } + } // if color > offset ... + } // if color && color_offset ... + } // if vid_d2 ... + } // for vid_d1_adj ... + } // for vid_adj ... + forbidden = ~(forbidden); + + // check if an available color exists. + if(forbidden) + { + color_t val = 1; + + // if there is an available color, choose the first color, using 2s complement. + bit_64_forbidden_t new_color = forbidden & (-forbidden); + + // convert it back to decimal color. + while((new_color & 1) == 0) + { + ++val; + new_color = new_color >> 1; + } + _colors(vid) = val + offset; + foundColor = true; + break; } + } // for !foundColor + } // if _colors(vid)==0 + } // if vid_ * _chunkSize ... + } // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVB_BIT (end) + + + + /** + * Functor for VBTP_BIT algorithm coloring without edge filtering. + * Two level parallelism + * - [P] Loop over chunks + * - [P] Loop over vertices in each chunk + * - ... + */ + struct functorGreedyColorVBTP_BIT + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColorVBTP_BIT(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } + + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t &thread) const + { + nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - const color_t c = _colors(vid_d2); + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) + { + if(chunk_id * _chunkSize + ichunk < _vertexListLength) + { + const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); + + // If vertex is not colored yet... + if(_colors(vid) == 0) + { + size_type vid_adj_begin = _idx(vid); + size_type vid_adj_end = _idx(vid + 1); - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) + bool foundColor = false; + for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) + { + // Forbidden colors + // - single long int for forbidden colors + bit_64_forbidden_t forbidden = 0; + + // If all available colors for this range are unavailable we can break out of the nested loops + bool break_out = false; + + // Loop over distance-1 neighbors of vid + for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) { - forbidden[c - offset] = true; + const nnz_lno_t vid_d1 = _adj(vid_adj); + size_type vid_d1_adj_begin = _t_idx(vid_d1); + size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + + // Loop over distance-2 neighbors of vid + for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + + // Ignore Distance-2 Self Loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t color = _colors(vid_d2); + color_t color_offset = color - offset; + + // if color is within the current range, or if its color is in a previously traversed + // range + if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) + { + // if it is in the current range, then add the color to the banned colors + if(color > offset) + { + // convert color to bit representation + bit_64_forbidden_t ban_color_bit = 1; + + ban_color_bit = ban_color_bit << (color_offset - 1); + + // add it to forbidden colors + forbidden = forbidden | ban_color_bit; + + // if there are no available colors in this range then exit early, + // no need to traverse the rest. + if(0 == ~forbidden) + { + break_out = true; + } + } + } + } // if vid_d2... + } // for vid_d1_adj... + } // for vid_adj... + forbidden = ~(forbidden); + + // check if an available color exists. + if(forbidden) + { + // if there is an available color, choose the first color, using 2s complement. + bit_64_forbidden_t new_color = forbidden & (-forbidden); + color_t val = 1; + + // convert it back to decimal color. + while((new_color & 1) == 0) + { + ++val; + new_color = new_color >> 1; + } + _colors(vid) = val + offset; + foundColor = true; + break; } - } - } + } // for !foundColor + } // if _colors(vid)==0 + } // if vid_ * _chunkSize ... + }); // parallel_for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVBTP_BIT (end) + + + + /** + * Functor for VB_BIT_EF algorithm coloring without edge filtering. + * Single level parallelism + */ + struct functorGreedyColorVB_BIT_EF + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + nnz_lno_temp_work_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_t _vertexListLength; // + nnz_lno_t _chunkSize; // + + functorGreedyColorVB_BIT_EF(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + nnz_lno_temp_work_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_t vertexListLength, + nnz_lno_t chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunkSize(chunkSize) + { + } - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + + // Color vertex i with smallest available color. + // + // Each thread colors a chunk of vertices to prevent all vertices getting the same color. + // + // This version uses a bool array of size FORBIDDEN_SIZE. + // + // param: ii = vertex id + // + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t vid_) const + { + nnz_lno_t vid = 0; + for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + { + if(vid_ * _chunkSize + ichunk < _vertexListLength) + { + vid = _vertexList(vid_ * _chunkSize + ichunk); + + // If vertex is not colored yet... + if(_colors(vid) == 0) { - if(!forbidden[c]) + size_type vid_adj_begin = _idx(vid); + size_type vid_adj_end = _idx(vid + 1); + + bool foundColor = false; + for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while !foundColor - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVB (end) + // Forbidden colors + // - single long int for forbidden colors + bit_64_forbidden_t forbidden = 0; + + // If all available colors for this range are unavailable we can break out of the nested loops + bool offset_colors_full = false; + + // Loop over distance-1 neighbors of vid + for(size_type vid_adj = vid_adj_begin; !offset_colors_full && vid_adj < vid_adj_end; ++vid_adj) + { + const nnz_lno_t vid_d1 = _adj(vid_adj); + + size_type vid_d1_adj_begin = _t_idx(vid_d1); + size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + + // Store the maximum color value found in the vertices adjacent to vid_d1 + color_t max_color_adj_to_d1 = 0; + + // Loop over distance-2 neighbors of vid + for(size_type vid_d1_adj = vid_d1_adj_begin; !offset_colors_full && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + + // Ignore Distance-2 Self Loops + if(vid_d2 != vid && vid_d2 < nv) + { + color_t color = _colors(vid_d2); + color_t color_offset = color - offset; + + // Update maximum color adjacent to vid_d1 found so far. + max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; + + // if color is within the current range, or if its color is in a previously traversed + // range + if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) + { + // if it is in the current range, then add the color to the banned colors + if(color > offset) + { + // convert color to bit representation + bit_64_forbidden_t ban_color_bit = 1; + + ban_color_bit = ban_color_bit << (color_offset - 1); + + // add it to forbidden colors + forbidden = forbidden | ban_color_bit; + + // if there are no available colors in this range then exit early, + // no need to traverse the rest. + if(0 == ~forbidden) + { + offset_colors_full = true; + } + } + } // if color && color_offset + } // if vid_d2 != vid ... + } // for vid_d1_adj ... + + // If we know that the all neighbors of vid_d1 are colored and they are + // in the current range or smaller then we can filter out the edge vid -> vid_d1 + // from future iterations. + if(offset_colors_full && max_color_adj_to_d1 <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) + { + if(vid_adj > vid_adj_begin) + { + _adj(vid_adj) = _adj(vid_adj_begin); + _adj(vid_adj_begin) = vid_d1; + } + vid_adj_begin++; + } + } // for vid_adj + forbidden = ~(forbidden); + + // check if an available color exists. + if(forbidden) + { + // if there is an available color, choose the first color, using 2s complement. + bit_64_forbidden_t new_color = forbidden & (-forbidden); + color_t val = 1; + + // convert it back to decimal color. + while((new_color & 1) == 0) + { + ++val; + new_color = new_color >> 1; + } + _colors(vid) = val + offset; + foundColor = true; + break; + } + } // for offset=0... + } // if _colors(vid)==0 + } // if vid_ * _chunkSize ... + } // for ichunk... + } // operator() (end) + }; // struct functorGreedyColorVB_BIT_EF (end) @@ -842,8 +1469,7 @@ class GraphColorD2 { nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) - { + Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { if(chunk_id * _chunkSize + ichunk < _vertexListLength) { const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); @@ -859,13 +1485,11 @@ class GraphColorD2 // atomics will be necessary for updating this. bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - // Do multiple passes if the array is too small. - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - - while(!foundColor && offset < nv) + // Do multiple passes if we fill the current range of possible colors + // * TODO: Determine if we can cap this at something smaller than nv, or if it matters. + for(color_t offset=0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) { - // initialize + // initialize the forbidden array to { false } for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for @@ -895,9 +1519,9 @@ class GraphColorD2 { forbidden[c - offset] = true; } - } - } - } + } // if vid_d2 != vid ... + } // for vid_d2_adj ... + } // for vid_d1_adj ... // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) @@ -908,12 +1532,11 @@ class GraphColorD2 foundColor = true; break; } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while(!foundColor) + } // for c=0 ... + } // for offset=0 ... } // if _colors(vid) <= 0 ... - } // if chunk_id*... - }); // for ichunk... + } // if chunk_id* ... + }); // for ichunk ... } // operator() (end) }; // struct functorGreedyColorVBTP (end) @@ -1296,7 +1919,6 @@ class GraphColorD2 - /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop-over -chunks @@ -1422,8 +2044,6 @@ class GraphColorD2 - - template struct functorFindConflicts_Atomic { @@ -1456,25 +2076,25 @@ class GraphColorD2 void operator()(const nnz_lno_t vid_, nnz_lno_t &numConflicts) const { typedef typename std::remove_reference::type atomic_incr_type; - const nnz_lno_t vid = _vertexList(vid_); - color_t my_color = _colors(vid); + const nnz_lno_t vid = _vertexList(vid_); + const color_t my_color = _colors(vid); - size_type vid_1adj = _idx(vid); - const size_type vid_1adj_end = _idx(vid + 1); + size_type vid_d1_adj = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); bool break_out = false; - for(; !break_out && vid_1adj < vid_1adj_end; vid_1adj++) + for(; !break_out && vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) { - nnz_lno_t vid_1idx = _adj(vid_1adj); + nnz_lno_t vid_d1 = _adj(vid_d1_adj); - for(size_type vid_2adj = _t_idx(vid_1idx); !break_out && vid_2adj < _t_idx(vid_1idx + 1); vid_2adj++) + for(size_type vid_d2_adj = _t_idx(vid_d1); !break_out && vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { - const nnz_lno_t vid_2idx = _t_adj(vid_2adj); + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - if(vid != vid_2idx && vid_2idx < nv) + if(vid != vid_d2 && vid_d2 < nv) { - if(_colors(vid_2idx) == my_color) + if(_colors(vid_d2) == my_color) { _colors(vid) = 0; // uncolor vertex @@ -1485,16 +2105,122 @@ class GraphColorD2 break_out = true; // break; // Can exit if vertex gets marked as a conflict. } + } // if vid != vid_d2 ... + } // for vid_d2_adj ... + } // for vid_d1_adj ... + } // operator() (end) + }; // struct functorFindConflicts_Atomic (end) + + + + /** + * functorVerifyDistance2Coloring + * - Validate correctness of the distance-2 coloring + */ + struct functorVerifyDistance2Coloring + { + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + non_const_1d_bool_view_t _flags; // [0]: valid or not? [1]=true means something is uncolored. [2]=true means something has distance-2 neighbor of same color + nnz_lno_t _chunkSize; // + + functorVerifyDistance2Coloring(nnz_lno_t nv_, + const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + non_const_1d_bool_view_t flags, + nnz_lno_t chunkSize) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _flags(flags) + , _chunkSize(chunkSize) + { + } + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t chunk_id) const + { + bool has_uncolored_vertex = false; + bool has_invalid_color = false; + bool has_color_bigger_than_num_verts = false; + + // Loop over vertices in chunks + for(nnz_lno_t chunk_idx = 0; chunk_idx < _chunkSize; chunk_idx++) + { + bool break_out = false; + nnz_lno_t vid = chunk_id * _chunkSize + chunk_idx; + + if(vid < nv) + { + const color_t color_vid = _colors(vid); + const size_type vid_d1_adj_begin = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); + + if(color_vid == 0) + { + has_uncolored_vertex = true; + } + + if(color_vid > nv) + { + has_color_bigger_than_num_verts = true; + } + + // Loop over neighbors of vid (distance-1 from vid) + for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + + // Loop over neighbors of vid_d1 (distance-2 from vid) + for(size_type vid_d2_adj = vid_d2_adj_begin; !break_out && vid_d2_adj < vid_d2_adj_end; ++vid_d2_adj) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + // Ignore Distance-2 self loops + if(vid != vid_d2) + { + const color_t color_d2 = _colors(vid_d2); + // If distance-2 neighbor of vid has the same color as vid, then the coloring is invalid + if(color_vid == color_d2) + { + has_invalid_color = true; + break_out = true; + std::cout << ">>> Invalid color match: " << vid << ", " << vid_d2 << " both have color " << color_vid << std::endl; + } + } + } } } } - } - }; // struct functorFindConflicts_Atomic (end) + if(has_uncolored_vertex || has_invalid_color) + Kokkos::atomic_fetch_or(&_flags[0], has_uncolored_vertex || has_invalid_color); + if(has_uncolored_vertex) + Kokkos::atomic_fetch_or(&_flags[1], has_uncolored_vertex); + if(has_invalid_color) + Kokkos::atomic_fetch_or(&_flags[2], has_invalid_color); + if(has_color_bigger_than_num_verts) + Kokkos::atomic_fetch_or(&_flags[3], has_color_bigger_than_num_verts); + } // operator() + }; // struct functorGreedyColorVB (end) + }; // end class GraphColorD2 + } // namespace Impl } // namespace KokkosGraph diff --git a/src/graph/impl/KokkosGraph_GraphColor_impl.hpp b/src/graph/impl/KokkosGraph_GraphColor_impl.hpp index 4b5d812d9b..afc1959384 100644 --- a/src/graph/impl/KokkosGraph_GraphColor_impl.hpp +++ b/src/graph/impl/KokkosGraph_GraphColor_impl.hpp @@ -65,7 +65,8 @@ namespace Impl{ * General aim is to find the minimum number of colors, minimum number of independent sets. */ template -class GraphColor { +class GraphColor +{ public: typedef lno_row_view_t_ in_lno_row_view_t; @@ -723,6 +724,8 @@ class GraphColor2: public GraphColor >> WCMCLEN GraphColor_VB::color_graph (KokkosGraph_GraphColor_impl.hpp)" << std::endl; - if (this->_ticToc) { std::cout << "\tVB params:" << std::endl @@ -934,7 +933,11 @@ class GraphColor_VB:public GraphColor _ticToc){ t = timer.seconds(); total += t; + total_time_greedy_phase += t; std::cout << "\tTime speculative greedy phase " << iter << " : " << t << std::endl; timer.reset(); } @@ -999,6 +1003,7 @@ class GraphColor_VB:public GraphColor cp->add_to_overall_coloring_time_phase1(total_time_greedy_phase); + this->cp->add_to_overall_coloring_time_phase2(total_time_find_conflicts); + this->cp->add_to_overall_coloring_time_phase3(total_time_serial_conflict_resolution); } // color_graph (end) @@ -1077,7 +1087,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 2) { - + //std::cout << ">>> functorGreedyColor_IMPLOG" << std::endl; // WCMCLEN functorGreedyColor_IMPLOG gc( this->nv, xadj_, adj_, @@ -1089,6 +1099,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 1){ + //std::cout << ">>> functorGreedyColor_IMP" << std::endl; // WCMCLEN functorGreedyColor_IMP gc( this->nv, xadj_, adj_, @@ -1101,7 +1112,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 0) { - + //std::cout << ">>> functorGreedyColor" << std::endl; // WCMCLEN functorGreedyColor gc( this->nv, xadj_, adj_, @@ -1131,8 +1142,6 @@ class GraphColor_VB:public GraphColor >> WCMCLEN GraphColor_VB::colorGreedyEF (KokkosGraph_GraphColor_impl.hpp)" << std::endl; - nnz_lno_t chunkSize_ = this->_chunkSize; // Process chunkSize vertices in one chunk if (current_vertexListLength_ < 100*chunkSize_) chunkSize_ = 1; @@ -1141,7 +1150,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 2) { //If edge filtering is applied - + //std::cout << ">>> functorGreedyColor_IMPLOG_EF" << std::endl; // WCMCLEN functorGreedyColor_IMPLOG_EF gc( this->nv, xadj_, adj_, @@ -1154,6 +1163,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 1){ + //std::cout << ">>> functorGreedyColor_IMP_EF" << std::endl; // WCMCLEN functorGreedyColor_IMP_EF gc( this->nv, xadj_, adj_, @@ -1165,7 +1175,7 @@ class GraphColor_VB:public GraphColor _use_color_set == 0) { -// std::cout << ">>> WCMCLEN GraphColor_VB::colorGreedyEF --- (call the functor)" << std::endl; + //std::cout << ">>> functorGreedyColor_EF" << std::endl; // WCMCLEN functorGreedyColor_EF gc( this->nv, xadj_, adj_, @@ -1718,7 +1728,6 @@ class GraphColor_VB:public GraphColor >> WCMCLEN functorGreedyColor_EF (KokkosGraph_GraphColor_impl.hpp) <<<" << std::endl; nnz_lno_t i = 0; for (nnz_lno_t ichunk=0; ichunk<_chunkSize; ichunk++){ if (ii*_chunkSize +ichunk < _vertexListLength) @@ -1825,8 +1834,6 @@ class GraphColor_VB:public GraphColor >> WCMCLEN functorGreedyColor (KokkosGraph_GraphColor_impl.hpp)" << std::endl; - nnz_lno_t i = 0; for (nnz_lno_t ichunk=0; ichunk<_chunkSize; ichunk++){ if (ii*_chunkSize +ichunk < _vertexListLength) @@ -2463,8 +2470,7 @@ class GraphColor_EB:public GraphColor >> WCMCLEN GraphColor_EB::color_graph()" << std::endl; + //std::cout << ">>> GraphColor_EB::color_graph()" << std::endl; // WCMCLEN //get EB parameters color_t numInitialColors = this->cp->get_eb_num_initial_colors(); @@ -2716,7 +2722,7 @@ class GraphColor_EB:public GraphColor Date: Thu, 5 Jul 2018 07:25:49 -0600 Subject: [PATCH 033/190] Testing Edge-Filtering Ideas --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 200 ++++++++++++++---- 1 file changed, 162 insertions(+), 38 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 2bb9ecdcee..faf4463b6a 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -49,6 +49,7 @@ #include #include #include +#include #include "KokkosGraph_GraphColor.hpp" #include "KokkosGraph_GraphColorHandle.hpp" @@ -65,6 +66,8 @@ namespace Impl { #define VB_D2_COLORING_FORBIDDEN_SIZE 64 #define VBBIT_D2_COLORING_FORBIDDEN_SIZE 64 +#define WCMCLEN_EXPERIMENTAL 0 + /*! * \brief Distance-2 Graph Coloring class * @@ -110,6 +113,7 @@ class GraphColorD2 typedef typename team_policy_t::member_type team_member_t; typedef Kokkos::View non_const_1d_bool_view_t; + typedef Kokkos::View non_const_1d_size_type_view_t; typedef long long int bit_64_forbidden_t; @@ -167,6 +171,8 @@ class GraphColorD2 virtual ~GraphColorD2() {} + + // ----------------------------------------------------------------- // // GraphColorD2::execute() @@ -188,6 +194,16 @@ class GraphColorD2 break; } + // EXPERIMENTAL Begin + #if WCMCLEN_EXPERIMENTAL + // Compute Distance-2 Degree of the vertices. + non_const_1d_size_type_view_t degree_d2 = non_const_1d_size_type_view_t("degree d2", this->nv); + if(using_edge_filtering) + { + this->calculate_d2_degree(degree_d2); + } + #endif + // EXPERIMENTAL End // Data: // gc_handle = graph coloring handle @@ -254,11 +270,17 @@ class GraphColorD2 // - This is required for edge-filtering passes to avoid // side effects since edge filtering modifies the adj array. nnz_lno_temp_work_view_t adj_copy; - adj_copy = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("adj copy"), this->ne); Kokkos::deep_copy(adj_copy, this->adj); - this->colorGreedyEF(this->xadj, adj_copy, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + non_const_clno_nnz_view_t t_adj_copy; + t_adj_copy = non_const_clno_nnz_view_t(Kokkos::ViewAllocateWithoutInitializing("t_adj copy"), this->ne); + Kokkos::deep_copy(t_adj_copy, this->t_adj); + + //prettyPrint1DView(t_adj_copy, "t_adj_copy", 100); + //prettyPrint1DView(t_adj, "t_adj", 100); + + this->colorGreedyEF(this->xadj, adj_copy, this->t_xadj, t_adj_copy, colors_out, current_vertexList, current_vertexListLength); } else { @@ -443,6 +465,8 @@ class GraphColorD2 private: + + // ----------------------------------------------------------------- // // GraphColorD2::colorGreedy() @@ -627,7 +651,7 @@ class GraphColorD2 void colorGreedyEF(const_lno_row_view_t xadj_, nnz_lno_temp_work_view_t adj_copy_, const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, + non_const_clno_nnz_view_t t_adj_copy_, color_view_type vertex_colors_, nnz_lno_temp_work_view_t current_vertexList_, nnz_lno_t current_vertexListLength_) @@ -652,7 +676,7 @@ class GraphColorD2 // 5. [S] loop over vertex neighbors of neighbors case COLORING_D2_VB_BIT_EF: { - functorGreedyColorVB_BIT_EF gc(this->nv, xadj_, adj_copy_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); + functorGreedyColorVB_BIT_EF gc(this->nv, xadj_, adj_copy_, t_xadj_, t_adj_copy_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); //prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); } @@ -844,6 +868,39 @@ class GraphColorD2 } // prettyPrint1DView (end) + // EXPERIMENTAL -- we might not need this for edge-filtering. + void calculate_d2_degree(non_const_1d_size_type_view_t degree_d2) + { + nnz_lno_t chunk_size = this->_chunkSize; + if(nv < 100 * chunk_size) + { + chunk_size = 1; + } + const size_t num_chunks = this->nv / chunk_size + 1; + + functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, chunk_size, degree_d2); + Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, num_chunks), calculateD2Degree); + + if(_ticToc) + { + prettyPrint1DView(degree_d2, "Degree D2", 150); + } + + size_type degree_d2_max = 0; + Kokkos::parallel_reduce("Max D2 Degree", this->nv, KOKKOS_LAMBDA(const int& i, size_type& lmax) + { + lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; + }, Kokkos::Max(degree_d2_max)); + std::cout << ">>> Max D2 Degree: " << degree_d2_max << std::endl; + + size_type degree_d2_sum = 0; + Kokkos::parallel_reduce("Sum D2 Degree", this->nv, KOKKOS_LAMBDA(const int& i, size_type& lsum) + { + lsum += degree_d2(i); + }, Kokkos::Sum(degree_d2_sum)); + std::cout << ">>> D2 Degree Sum: " << degree_d2_sum << std::endl; + } + public: // ------------------------------------------------------ @@ -1274,27 +1331,27 @@ class GraphColorD2 */ struct functorGreedyColorVB_BIT_EF { - nnz_lno_t nv; // num vertices + nnz_lno_t _nv; // num vertices const_lno_row_view_t _idx; // vertex degree list - nnz_lno_temp_work_view_t _adj; // vertex adjacency list + nnz_lno_temp_work_view_t _adj; // vertex adjacency list (mutable) const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + non_const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list (mutable) color_view_type _colors; // vertex colors nnz_lno_temp_work_view_t _vertexList; // nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // + nnz_lno_t _chunk_size; // - functorGreedyColorVB_BIT_EF(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - nnz_lno_temp_work_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, + functorGreedyColorVB_BIT_EF(nnz_lno_t nv, + const_lno_row_view_t xadj, + nnz_lno_temp_work_view_t adj, + const_clno_row_view_t t_xadj, + non_const_clno_nnz_view_t t_adj, color_view_type colors, nnz_lno_temp_work_view_t vertexList, nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) + nnz_lno_t chunk_size) + : _nv(nv), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _colors(colors), _vertexList(vertexList), + _vertexListLength(vertexListLength), _chunk_size(chunk_size) { } @@ -1308,23 +1365,28 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_) const + void operator()(const nnz_lno_t chunk_idx) const { - nnz_lno_t vid = 0; - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + //typedef typename Kokkos::UnorderedMap unordered_map_t; // EXPERIMENTAL + + for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) { - if(vid_ * _chunkSize + ichunk < _vertexListLength) + const nnz_lno_t vid_idx = chunk_idx * _chunk_size + ichunk; + + if(vid_idx < _vertexListLength) { - vid = _vertexList(vid_ * _chunkSize + ichunk); + const nnz_lno_t vid = _vertexList(vid_idx); - // If vertex is not colored yet... + // If vertex is not colored yet.. if(_colors(vid) == 0) { size_type vid_adj_begin = _idx(vid); size_type vid_adj_end = _idx(vid + 1); + //size_type degree_vid = vid_adj_end - vid_adj_begin; // EXPERIMENTAL + //unordered_map_t map(degree_vid); // EXPERIMENTAL bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) + for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { // Forbidden colors // - single long int for forbidden colors @@ -1340,6 +1402,14 @@ class GraphColorD2 size_type vid_d1_adj_begin = _t_idx(vid_d1); size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + //size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; + + //if( !map.exists(vid_d1) ) // EXPERIMENTAL + //{ // EXPERIMENTAL + // size_type color_flags[2] = {0}; // EXPERIMENTAL + // Kokkos::View color_flags("color_flags", 2); // EXPERIMENTAL + // map.insert(vid_d1, &color_flags); // EXPERIMENTAL + //} // EXPERIMENTAL // Store the maximum color value found in the vertices adjacent to vid_d1 color_t max_color_adj_to_d1 = 0; @@ -1350,10 +1420,10 @@ class GraphColorD2 const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); // Ignore Distance-2 Self Loops - if(vid_d2 != vid && vid_d2 < nv) + if(vid_d2 != vid && vid_d2 < _nv) { color_t color = _colors(vid_d2); - color_t color_offset = color - offset; + color_t color_offset = color - offset; // color_offset < 0 == color is from a previous offset. // Update maximum color adjacent to vid_d1 found so far. max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; @@ -1362,6 +1432,18 @@ class GraphColorD2 // range if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) { + // If vid_d2 is already colored and it's within the current range or a previously + // traversed range we can 'filter' it out so it won't participate + // in higher offset value visits. + // todo: can we extend this to allow other vid's on the same thread to also + // todo: filter out paths vid -> d1 -> d2 if d2 is known to be colored? + if(vid_d1_adj > vid_d1_adj_begin) + { + _t_adj(vid_d1_adj) = _t_adj(vid_d1_adj_begin); + _t_adj(vid_d1_adj_begin) = vid_d2; + } + vid_d1_adj_begin++; + // if it is in the current range, then add the color to the banned colors if(color > offset) { @@ -1383,19 +1465,6 @@ class GraphColorD2 } // if color && color_offset } // if vid_d2 != vid ... } // for vid_d1_adj ... - - // If we know that the all neighbors of vid_d1 are colored and they are - // in the current range or smaller then we can filter out the edge vid -> vid_d1 - // from future iterations. - if(offset_colors_full && max_color_adj_to_d1 <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - if(vid_adj > vid_adj_begin) - { - _adj(vid_adj) = _adj(vid_adj_begin); - _adj(vid_adj_begin) = vid_d1; - } - vid_adj_begin++; - } } // for vid_adj forbidden = ~(forbidden); @@ -2216,6 +2285,61 @@ class GraphColorD2 }; // struct functorGreedyColorVB (end) + // EXPERIMENTAL Begin + /** + * functorVerifyDistance2Coloring + * - Validate correctness of the distance-2 coloring + */ + struct functorCalculateD2Degree + { + nnz_lno_t num_verts; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + nnz_lno_t _chunk_size; // Chunksize (threads work on |chunk_size| number of verts in batch. + non_const_1d_size_type_view_t _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) + + functorCalculateD2Degree(nnz_lno_t num_verts, + const_lno_row_view_t xadj, + const_lno_nnz_view_t adj, + const_clno_row_view_t t_xadj, + const_clno_nnz_view_t t_adj, + nnz_lno_t chunk_size, + non_const_1d_size_type_view_t degree_d2) + : num_verts(num_verts), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _chunk_size(chunk_size), _degree_d2(degree_d2) + { + } + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t chunk_id) const + { + // Loop over vertices in chunks + for(nnz_lno_t chunk_idx = 0; chunk_idx < _chunk_size; chunk_idx++) + { + nnz_lno_t vid = chunk_id * _chunk_size + chunk_idx; + if(vid < num_verts) + { + const size_type vid_d1_adj_begin = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); + + // Loop over neighbors of vid (distance-1 from vid) + for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; + _degree_d2(vid) += degree_vid_d1; + } // for vid_d1_adj ... + } // if vid < nv ... + } // for chunk_idx ... + } // operator() (end) + }; // struct functorCalculateD2Degree (end) + // EXPERIMENTAL End + + + }; // end class GraphColorD2 From c3adeee5e05fb56a6828006614eadeb54c48afa0 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 19 Jul 2018 14:12:11 -0600 Subject: [PATCH 034/190] disable extra configuration verbosity in d2 coloring --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 4 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 48 +++++++++---------- 2 files changed, 25 insertions(+), 27 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 5e39d7c568..f536011318 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -791,7 +791,9 @@ int main(int argc, char *argv[]) const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads const int device_id = 0; Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); - Kokkos::print_configuration(std::cout); + + // Print out verbose information about the configuration of the run. + // Kokkos::print_configuration(std::cout); #if defined(KOKKOS_ENABLE_OPENMP) if(params.use_openmp) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index faf4463b6a..68cf6c56a4 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1189,7 +1189,9 @@ class GraphColorD2 * Two level parallelism * - [P] Loop over chunks * - [P] Loop over vertices in each chunk - * - ... + * - [S] Loop over offset range(s) + * - [S] Loop over neighbors of vid: vid_d1 + * - [S] Loop over neighbors of vid_d1: vid_d2 */ struct functorGreedyColorVBTP_BIT { @@ -1367,8 +1369,6 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const nnz_lno_t chunk_idx) const { - //typedef typename Kokkos::UnorderedMap unordered_map_t; // EXPERIMENTAL - for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) { const nnz_lno_t vid_idx = chunk_idx * _chunk_size + ichunk; @@ -1383,7 +1383,6 @@ class GraphColorD2 size_type vid_adj_begin = _idx(vid); size_type vid_adj_end = _idx(vid + 1); //size_type degree_vid = vid_adj_end - vid_adj_begin; // EXPERIMENTAL - //unordered_map_t map(degree_vid); // EXPERIMENTAL bool foundColor = false; for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) @@ -1400,16 +1399,10 @@ class GraphColorD2 { const nnz_lno_t vid_d1 = _adj(vid_adj); - size_type vid_d1_adj_begin = _t_idx(vid_d1); - size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - //size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; - - //if( !map.exists(vid_d1) ) // EXPERIMENTAL - //{ // EXPERIMENTAL - // size_type color_flags[2] = {0}; // EXPERIMENTAL - // Kokkos::View color_flags("color_flags", 2); // EXPERIMENTAL - // map.insert(vid_d1, &color_flags); // EXPERIMENTAL - //} // EXPERIMENTAL + size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; + size_type num_vid_d2_colored_in_range = 0; // Store the maximum color value found in the vertices adjacent to vid_d1 color_t max_color_adj_to_d1 = 0; @@ -1423,7 +1416,7 @@ class GraphColorD2 if(vid_d2 != vid && vid_d2 < _nv) { color_t color = _colors(vid_d2); - color_t color_offset = color - offset; // color_offset < 0 == color is from a previous offset. + color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. // Update maximum color adjacent to vid_d1 found so far. max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; @@ -1432,17 +1425,7 @@ class GraphColorD2 // range if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - // If vid_d2 is already colored and it's within the current range or a previously - // traversed range we can 'filter' it out so it won't participate - // in higher offset value visits. - // todo: can we extend this to allow other vid's on the same thread to also - // todo: filter out paths vid -> d1 -> d2 if d2 is known to be colored? - if(vid_d1_adj > vid_d1_adj_begin) - { - _t_adj(vid_d1_adj) = _t_adj(vid_d1_adj_begin); - _t_adj(vid_d1_adj_begin) = vid_d2; - } - vid_d1_adj_begin++; + num_vid_d2_colored_in_range++; // if it is in the current range, then add the color to the banned colors if(color > offset) @@ -1465,6 +1448,19 @@ class GraphColorD2 } // if color && color_offset } // if vid_d2 != vid ... } // for vid_d1_adj ... + + // Edge filtering on the neighbors of vid. We can only do this if ALL neighbors of vid_d1 + // have been visited and if they're colored in current offset range or lower. + if(degree_vid_d1 == num_vid_d2_colored_in_range) + { + if(vid_adj_begin > vid_adj) + { + _adj(vid_adj) = _adj(vid_adj_begin); + _adj(vid_adj_begin) = vid_d1; + } + vid_adj_begin++; + } + } // for vid_adj forbidden = ~(forbidden); From 06523c74d849ffee6337c58e781c616cdf90c309 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 20 Jul 2018 14:55:35 -0600 Subject: [PATCH 035/190] STYLE: Adding notes --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 68cf6c56a4..0f7861d008 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1443,6 +1443,8 @@ class GraphColorD2 if(0 == ~forbidden) { offset_colors_full = true; + // Note: with edge-filtering, this will short-circuit the loop over all + // neighbors of VID and will reduce the number of filtered edges. } } } // if color && color_offset From a7b8114082d9c69576c73905c7e2cc4d03f33826 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 23 Jul 2018 16:47:19 -0600 Subject: [PATCH 036/190] D2 Coloring compilation fix --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 0f7861d008..a68af4212b 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -2290,7 +2290,7 @@ class GraphColorD2 */ struct functorCalculateD2Degree { - nnz_lno_t num_verts; // num vertices + nnz_lno_t _num_verts; // num vertices const_lno_row_view_t _idx; // vertex degree list const_lno_nnz_view_t _adj; // vertex adjacency list const_clno_row_view_t _t_idx; // transpose vertex degree list @@ -2305,7 +2305,7 @@ class GraphColorD2 const_clno_nnz_view_t t_adj, nnz_lno_t chunk_size, non_const_1d_size_type_view_t degree_d2) - : num_verts(num_verts), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _chunk_size(chunk_size), _degree_d2(degree_d2) + : _num_verts(num_verts), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _chunk_size(chunk_size), _degree_d2(degree_d2) { } @@ -2316,7 +2316,7 @@ class GraphColorD2 for(nnz_lno_t chunk_idx = 0; chunk_idx < _chunk_size; chunk_idx++) { nnz_lno_t vid = chunk_id * _chunk_size + chunk_idx; - if(vid < num_verts) + if(vid < _num_verts) { const size_type vid_d1_adj_begin = _idx(vid); const size_type vid_d1_adj_end = _idx(vid + 1); From beff72b7f2e8ca12def74c19d9a3b15cea2dcc74 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 24 Jul 2018 12:34:08 -0600 Subject: [PATCH 037/190] D2 Color: Account for d2-self-loop in edge filtering --- src/graph/KokkosGraph_Distance2Color.hpp | 3 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 37 +++++++++++-------- 2 files changed, 22 insertions(+), 18 deletions(-) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index bd0d7b8dbb..802ddc234e 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -85,7 +85,7 @@ void graph_color_d2(KernelHandle *handle, switch(algorithm) { - case COLORING_SPGEMM: // WCMCLEN: Remove SPGEMM coloring references for D2 Graph Coloring? + case COLORING_SPGEMM: case COLORING_D2_MATRIX_SQUARED: { Impl::GraphColorD2_MatrixSquared @@ -98,7 +98,6 @@ void graph_color_d2(KernelHandle *handle, { #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; - std::cout << "KokkosGraph_Distance2Color.hpp::COLORING_D2_SERIAL" << std::endl; Impl::GraphColor gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index a68af4212b..6269b7fbd7 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1382,7 +1382,6 @@ class GraphColorD2 { size_type vid_adj_begin = _idx(vid); size_type vid_adj_end = _idx(vid + 1); - //size_type degree_vid = vid_adj_end - vid_adj_begin; // EXPERIMENTAL bool foundColor = false; for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) @@ -1399,9 +1398,9 @@ class GraphColorD2 { const nnz_lno_t vid_d1 = _adj(vid_adj); - size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; + size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; size_type num_vid_d2_colored_in_range = 0; // Store the maximum color value found in the vertices adjacent to vid_d1 @@ -1416,7 +1415,7 @@ class GraphColorD2 if(vid_d2 != vid && vid_d2 < _nv) { color_t color = _colors(vid_d2); - color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. + color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. // Update maximum color adjacent to vid_d1 found so far. max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; @@ -1443,25 +1442,31 @@ class GraphColorD2 if(0 == ~forbidden) { offset_colors_full = true; - // Note: with edge-filtering, this will short-circuit the loop over all + // Note: with edge-filtering, this can short-circuit the loop over all // neighbors of VID and will reduce the number of filtered edges. } - } + } // if color > offset } // if color && color_offset } // if vid_d2 != vid ... + else + { + // If there's a self-loop then we should increment our 'colored in range' so we don't + // block filtering since we know there must be a (v2,v1) edge + num_vid_d2_colored_in_range++; + } } // for vid_d1_adj ... - // Edge filtering on the neighbors of vid. We can only do this if ALL neighbors of vid_d1 - // have been visited and if they're colored in current offset range or lower. - if(degree_vid_d1 == num_vid_d2_colored_in_range) + // Edge filtering on the neighbors of vid. We can only do this if ALL neighbors of vid_d1 + // have been visited and if all were colored in current offset range or lower. + if(degree_vid_d1 == num_vid_d2_colored_in_range) + { + if(vid_adj_begin > vid_adj) { - if(vid_adj_begin > vid_adj) - { - _adj(vid_adj) = _adj(vid_adj_begin); - _adj(vid_adj_begin) = vid_d1; - } - vid_adj_begin++; + _adj(vid_adj) = _adj(vid_adj_begin); + _adj(vid_adj_begin) = vid_d1; } + vid_adj_begin++; + } } // for vid_adj forbidden = ~(forbidden); From b1fe28f5bf62a55275bceea74cfe44f0fcc45f10 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 24 Jul 2018 12:48:48 -0600 Subject: [PATCH 038/190] D2 Coloring: Set TP variant to KOKKOS::AUTO --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 6269b7fbd7..c5410f4d50 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -517,8 +517,7 @@ class GraphColorD2 #if defined(KOKKOS_ENABLE_CUDA) const team_policy_t policy_inst(num_chunks, chunkSize_); #else - //const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - const team_policy_t policy_inst(num_chunks, chunkSize_); + const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); #endif Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); @@ -1438,7 +1437,8 @@ class GraphColorD2 forbidden = forbidden | ban_color_bit; // if there are no available colors in this range then exit early, - // no need to traverse the rest. + // no need to traverse the rest b/c they contribute no new information + // at this offset. if(0 == ~forbidden) { offset_colors_full = true; From d1d79997d080a2a7a4fbeff50da1eef18711ac8e Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 6 Aug 2018 13:57:48 -0600 Subject: [PATCH 039/190] Updated histogram CSV summary printout for D2 Coloring --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 27 +++++++++++++++-- src/graph/KokkosGraph_Distance2Color.hpp | 11 +++++-- .../impl/KokkosGraph_Distance2Color_impl.hpp | 29 +++++++++++++++---- 3 files changed, 57 insertions(+), 10 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index f536011318..106be5a7e5 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -526,7 +526,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Validation : " << all_results_valid_str << std::endl << std::endl; - std::cout << "CSVHDR" + std::cout << "CSVTIMEHDR" << "," << "Filename" << "," << "Host" << "," << "Num Rows" @@ -546,7 +546,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Validation" << std::endl; - std::cout << "CSVDATA" + std::cout << "CSVTIMEDATA" << "," << a_mtx_bin_file << "," << hostname << "," << crsGraph.numRows() @@ -566,6 +566,29 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << all_results_valid_str << std::endl; + std::cout << "CSVHISTHDR" + << "," << "Filename" + << "," << "Host" + << "," << "Num Rows" + << "," << "Num Edges" + << "," << "Execution Space" + << "," << "Algorithm" + << "," << "Concurrency" + << "," << "Histogram: 1 .. N" + << std::endl; + + + std::cout << "CSVHISTDATA" + << "," << a_mtx_bin_file + << "," << hostname + << "," << crsGraph.numRows() + << "," << crsGraph.entries.dimension_0() + << "," << Kokkos::DefaultExecutionSpace::name() + << "," << label_algorithm + << "," << Kokkos::DefaultExecutionSpace::concurrency(); + printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); + std::cout << std::endl; + // Kokkos::print_configuration(std::cout); } diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 802ddc234e..63c6db419d 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -190,12 +190,19 @@ void printDistance2ColorsHistogram(KernelHandle *handle, lno_nnz_view_t_ row_entries, // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries) + lno_colnnz_view_t_ col_entries, bool csv=false) { Impl::GraphColorD2 gc( num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.printDistance2ColorsHistogram(); + if(csv) + { + gc.printDistance2ColorsHistogramCSV(); + } + else + { + gc.printDistance2ColorsHistogram(); + } } diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index c5410f4d50..5947cedc58 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -446,16 +446,33 @@ class GraphColorD2 /** * Print out the distance-2 coloring histogram. */ - void printDistance2ColorsHistogram(void) + void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) { - nnz_lno_t num_colors = this->gc_handle->get_num_colors(); - std::cout << "num_colors: " << num_colors << std::endl; + MyExecSpace::fence(); + KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); + } + void printDistance2ColorsHistogramCSV() + { + nnz_lno_t num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); - MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram( - this->nv, this->gc_handle->get_vertex_colors(), histogram); + this->getDistance2ColorsHistogram(histogram); + + size_t i=0; + for(i=1; i< histogram.extent(0)-1; i++) + { + std::cout << histogram(i) << ","; + } + std::cout << histogram(i); + + } + void printDistance2ColorsHistogram() + { + nnz_lno_t num_colors = this->gc_handle->get_num_colors(); + nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); + this->getDistance2ColorsHistogram(histogram); std::cout << ">>> Histogram: " << std::endl; KokkosKernels::Impl::kk_print_1Dview(histogram); std::cout << std::endl; From 2ff4c9f92caff618b127195758a14e377611b7d1 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 6 Aug 2018 15:27:19 -0600 Subject: [PATCH 040/190] D2 Color style fix --- perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 106be5a7e5..471492843d 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -585,7 +585,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() << "," << label_algorithm - << "," << Kokkos::DefaultExecutionSpace::concurrency(); + << "," << Kokkos::DefaultExecutionSpace::concurrency() + << ","; printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); std::cout << std::endl; From 10ce952eac5e6e805bfc3713f857f21c6a41becf Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 9 Aug 2018 09:40:09 -0600 Subject: [PATCH 041/190] D2 Coloring: Output histogram of colors from driver --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 6 ++-- .../impl/KokkosGraph_Distance2Color_impl.hpp | 36 ++++++++++--------- 2 files changed, 22 insertions(+), 20 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 471492843d..0b71ba2edb 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -313,9 +313,9 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; KernelHandle kh; - kh.set_team_work_size(chunk_size); // WCMCLEN - Team Policy + kh.set_team_work_size(chunk_size); kh.set_shmem_size(shmemsize); - kh.set_suggested_team_size(team_size); // WCMCLEN - Team Policy + kh.set_suggested_team_size(team_size); kh.set_suggested_vector_size(vector_size); if(use_dynamic_scheduling) @@ -457,7 +457,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // ------------------------------------------ // Print out the colors histogram // ------------------------------------------ - printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); } // for i... diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 5947cedc58..c2725accb4 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -369,14 +369,6 @@ class GraphColorD2 this->gc_handle->set_vertex_colors(colors_out); this->gc_handle->set_num_phases((double)iter); - // ------------------------------------------ - // Print out histogram of colors - // ------------------------------------------ - if(_ticToc) - { - //prettyPrint1DView(colors_out, ">>> colors_out ", 500); // WCMCLEN - //printDistance2ColorsHistogram(); - } } // color_graph_d2 (end) @@ -444,15 +436,8 @@ class GraphColorD2 /** - * Print out the distance-2 coloring histogram. + * Print out the histogram of colors in CSV format. */ - void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) - { - MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); - } - void printDistance2ColorsHistogramCSV() { nnz_lno_t num_colors = this->gc_handle->get_num_colors(); @@ -468,6 +453,10 @@ class GraphColorD2 } + /** + * Print out the histogram of colors in a more human friendly format + * This will not print out all the colors if there are many. + */ void printDistance2ColorsHistogram() { nnz_lno_t num_colors = this->gc_handle->get_num_colors(); @@ -480,10 +469,23 @@ class GraphColorD2 - private: + + /** + * Generate a histogram of the distance-2 colors. + * - histogram must be of size num_colors+1 + */ + void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) + { + MyExecSpace::fence(); + KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); + } + + + // ----------------------------------------------------------------- // // GraphColorD2::colorGreedy() From 12831fd4391d1cd9bf5bce4db774975b50a1c0c6 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 9 Aug 2018 18:06:42 -0600 Subject: [PATCH 042/190] D2 Coloring - Update command line options help --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 0b71ba2edb..ac473cbd5a 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -111,17 +111,21 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << spaces << " amtx Input file in Matrix Market format (.mtx)." << std::endl << std::endl << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl - << spaces << " COLORING_D2_MATRIX_SQUARED - Distance-2 coloring using matrix-squared + Distance-1 coloring method." << std::endl - << spaces << " COLORING_D2_VB - Distance-2 coloring using direct method." << std::endl - << spaces << " COLORING_D2_VBTP - Distance-2 coloring using direct method + Team Policy." << std::endl + << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl + << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl + << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array." << std::endl + << spaces << " COLORING_D2_VBTP - VB with Team Policy (type 1)" << std::endl + << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl + << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl + << std::endl << spaces << " Optional Parameters:" << std::endl + << spaces << " repeat Set number of test repetitions (Default: 1) " << std::endl + << spaces << " verbose Enable verbose mode (record and print timing + extra information)" << std::endl << spaces << " chunksize Set the chunk size." << std::endl << spaces << " dynamic Use dynamic scheduling." << std::endl - << spaces << " repeat Set number of test repetitions (Default: 6) " << std::endl << spaces << " teamsize Set the team size." << std::endl << spaces << " vectorsize Set the vector size." << std::endl - << spaces << " verbose Enable verbose mode (record and print timing + extra information)" << std::endl << spaces << " help Print out command line help." << std::endl << spaces << " " << std::endl; } @@ -798,6 +802,9 @@ int main(int argc, char *argv[]) { KokkosKernels::Experiment::Parameters params; + // Override default repeats (default is 6) + params.repeat = 1; + if(parse_inputs(params, argc, argv)) { return 1; From a5bf3452f2cc98b24e2f27359752ce86ef55b161 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 9 Aug 2018 19:06:54 -0600 Subject: [PATCH 043/190] D2 Coloring - calculate distance2 degree --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 21 +++ src/graph/KokkosGraph_Distance2Color.hpp | 51 +++++- src/graph/KokkosGraph_GraphColorHandle.hpp | 4 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 168 ++++++++++-------- 4 files changed, 160 insertions(+), 84 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index ac473cbd5a..5d240878c0 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -312,6 +312,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; @@ -465,6 +466,19 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) } // for i... + // ------------------------------------------ + // Compute Distance 2 Degree Stats + // ------------------------------------------ + typedef typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; + non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); + + size_t degree_d2_max=0; + size_t degree_d2_sum=0; + computeDistance2Degree(&kh, crsGraph.numRows(), crsGraph.numCols(), + crsGraph.row_map, crsGraph.entries, + crsGraph.row_map, crsGraph.entries, + degree_d2_dist, degree_d2_max, degree_d2_sum); + double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); @@ -514,6 +528,9 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl << " Algorithm : " << label_algorithm << std::endl + << "Graph Stats" << std::endl + << " Degree D2 Max : " << degree_d2_max << std::endl + << " Degree D2 Sum : " << degree_d2_sum << std::endl << "Overall Time/Stats" << std::endl << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl @@ -547,6 +564,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Total Time RC" << "," << "Avg Colors" << "," << "Avg Num Phases" + << "," << "Degree D2 Max" + << "," << "Degree D2 Sum" << "," << "Validation" << std::endl; @@ -567,6 +586,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << total_time_resolve_conflicts << "," << avg_colors << "," << avg_phases + << "," << degree_d2_max + << "," << degree_d2_sum << "," << all_results_valid_str << std::endl; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 63c6db419d..34ffe6a0ef 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -140,6 +140,49 @@ void graph_color_d2(KernelHandle *handle, } +/** + * Compute Distance-2 Degree Stats + * + * Distance-2 Degree of a vertex, v, is the sum of the degree of all neighbors of v. + * + * This function calculates the distance-2 degree of all the vertices in the graph, + * the maximum distance-2 degree, and the sum of all the distance-2 degrees. + * + * @param[in] handle The Kernel Handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map Row map + * @param[in] row_entries Row entries + * @param[in] col_map Column map + * @param[in] col_entries Column entries + * @param[out] degree_d2_dist View to fill with distance-2 degree information. + * @param[out] degree_d2_max Maximum distance-2 degree found. + * @param[out] degree_d2_sum Sum of all distance-2 degrees. + * + * Note: If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @return Nothing + */ +template +void computeDistance2Degree(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, + size_t& degree_d2_max, + size_t& degree_d2_sum) +{ + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + + gc.calculate_d2_degree(degree_d2_dist, degree_d2_max, degree_d2_sum); +} + + /** * Validate Distance 2 Graph Coloring @@ -169,8 +212,8 @@ bool verifyDistance2Coloring(KernelHandle *handle, typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); - Impl::GraphColorD2 gc( - num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch->get_vertex_colors(), validation_flags); @@ -192,8 +235,8 @@ void printDistance2ColorsHistogram(KernelHandle *handle, lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries, bool csv=false) { - Impl::GraphColorD2 gc( - num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); if(csv) { diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 88f8a218a9..91380acf3f 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -122,6 +122,8 @@ class GraphColoringHandle typedef Kokkos::TeamPolicy team_policy_t ; typedef typename team_policy_t::member_type team_member_t ; + typedef typename Kokkos::View non_const_1d_size_type_view_t; + private: ColoringType GraphColoringType; @@ -188,7 +190,7 @@ class GraphColoringHandle tictoc(false), vb_edge_filtering(false), vb_chunk_size(8), - max_number_of_iterations(50), // WCMCLEN SCAFFOLDING Change back to default = 200 + max_number_of_iterations(200), eb_num_initial_colors(1), overall_coloring_time(0), overall_coloring_time_phase1(0), diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index c2725accb4..50f4a7a178 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -113,7 +113,8 @@ class GraphColorD2 typedef typename team_policy_t::member_type team_member_t; typedef Kokkos::View non_const_1d_bool_view_t; - typedef Kokkos::View non_const_1d_size_type_view_t; + //typedef Kokkos::View non_const_1d_size_type_view_t; + typedef typename HandleType::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; typedef long long int bit_64_forbidden_t; @@ -138,6 +139,13 @@ class GraphColorD2 char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). bool _ticToc; // if true print info in each step +#if 0 + bool _degree_d2_is_set; + non_const_1d_size_type_view_t _degree_d2; + size_type _degree_d2_max; + size_type _degree_d2_sum; +#endif + public: /** @@ -157,10 +165,11 @@ class GraphColorD2 const_clno_row_view_t t_row_map, const_clno_nnz_view_t t_entries, HandleType *handle) - : nv(nv_), nr(nv_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), - gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()), - _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1), - _use_color_set(0), _ticToc(handle->get_verbose()) + : nv(nv_), nr(nv_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries) + ,gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()) + ,_max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1) + ,_use_color_set(0), _ticToc(handle->get_verbose()) +// ,_degree_d2_is_set(false), _degree_d2(NULL), _degree_d2_max(0), _degree_d2_sum(0) { } @@ -194,17 +203,6 @@ class GraphColorD2 break; } - // EXPERIMENTAL Begin - #if WCMCLEN_EXPERIMENTAL - // Compute Distance-2 Degree of the vertices. - non_const_1d_size_type_view_t degree_d2 = non_const_1d_size_type_view_t("degree d2", this->nv); - if(using_edge_filtering) - { - this->calculate_d2_degree(degree_d2); - } - #endif - // EXPERIMENTAL End - // Data: // gc_handle = graph coloring handle // nr = num_rows (scalar) @@ -229,6 +227,21 @@ class GraphColorD2 // prettyPrint1DView(this->adj, ">>> adj ", 500); } + #if 0 + // Compute Distance-2 Degree of the vertices. + // -- Keeping this around in case we need to use it later on as an example. + size_t degree_d2_max=0; + size_t degree_d2_sum=0; + non_const_1d_size_type_view_t degree_d2 = non_const_1d_size_type_view_t("degree d2", this->nv); + this->calculate_d2_degree(degree_d2, degree_d2_max, degree_d2_sum); + if(true || _ticToc ) + { + prettyPrint1DView(degree_d2, "Degree D2", 150); + std::cout << ">>> Max D2 Degree: " << degree_d2_max << std::endl; + std::cout << ">>> D2 Degree Sum: " << degree_d2_sum<< std::endl; + } + #endif + // conflictlist - store conflicts that can happen when we're coloring in parallel. nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); @@ -886,39 +899,6 @@ class GraphColorD2 } // prettyPrint1DView (end) - // EXPERIMENTAL -- we might not need this for edge-filtering. - void calculate_d2_degree(non_const_1d_size_type_view_t degree_d2) - { - nnz_lno_t chunk_size = this->_chunkSize; - if(nv < 100 * chunk_size) - { - chunk_size = 1; - } - const size_t num_chunks = this->nv / chunk_size + 1; - - functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, chunk_size, degree_d2); - Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, num_chunks), calculateD2Degree); - - if(_ticToc) - { - prettyPrint1DView(degree_d2, "Degree D2", 150); - } - - size_type degree_d2_max = 0; - Kokkos::parallel_reduce("Max D2 Degree", this->nv, KOKKOS_LAMBDA(const int& i, size_type& lmax) - { - lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; - }, Kokkos::Max(degree_d2_max)); - std::cout << ">>> Max D2 Degree: " << degree_d2_max << std::endl; - - size_type degree_d2_sum = 0; - Kokkos::parallel_reduce("Sum D2 Degree", this->nv, KOKKOS_LAMBDA(const int& i, size_type& lsum) - { - lsum += degree_d2(i); - }, Kokkos::Sum(degree_d2_sum)); - std::cout << ">>> D2 Degree Sum: " << degree_d2_sum << std::endl; - } - public: // ------------------------------------------------------ @@ -2307,19 +2287,55 @@ class GraphColorD2 }; // struct functorGreedyColorVB (end) - // EXPERIMENTAL Begin + + /** + * Calculate the distance-2 degree of all the vertices in the graph. + * + * @param degree_d2 : A mutable view of size |V| + * @param degree_d2_max : Saves the max distance-2 degree value in. + * @param degree_d2_sum : Saves the sum of the distance-2 degrees + * of all vertices. + */ + void calculate_d2_degree(non_const_1d_size_type_view_t& degree_d2, size_t& degree_d2_max, size_t& degree_d2_sum) + { + functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, degree_d2); + Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, this->nv), calculateD2Degree); + + // Compute maximum d2 degree + size_t _degree_d2_max = 0; + Kokkos::parallel_reduce("Max D2 Degree", + this->nv, + KOKKOS_LAMBDA(const size_t &i, size_t &lmax) + { + lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; + }, + Kokkos::Max(_degree_d2_max)); + degree_d2_max = _degree_d2_max; + + // Compute the sum of all d2 degrees + size_t _degree_d2_sum = 0; + Kokkos::parallel_reduce("Sum D2 Degree", + this->nv, + KOKKOS_LAMBDA(const size_t &i, size_t &lsum) + { + lsum += degree_d2(i); + }, + Kokkos::Sum(_degree_d2_sum)); + degree_d2_sum = _degree_d2_sum; + } + + /** * functorVerifyDistance2Coloring * - Validate correctness of the distance-2 coloring */ struct functorCalculateD2Degree { - nnz_lno_t _num_verts; // num vertices + nnz_lno_t _num_verts; // num vertices const_lno_row_view_t _idx; // vertex degree list const_lno_nnz_view_t _adj; // vertex adjacency list const_clno_row_view_t _t_idx; // transpose vertex degree list const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - nnz_lno_t _chunk_size; // Chunksize (threads work on |chunk_size| number of verts in batch. non_const_1d_size_type_view_t _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) functorCalculateD2Degree(nnz_lno_t num_verts, @@ -2327,39 +2343,33 @@ class GraphColorD2 const_lno_nnz_view_t adj, const_clno_row_view_t t_xadj, const_clno_nnz_view_t t_adj, - nnz_lno_t chunk_size, - non_const_1d_size_type_view_t degree_d2) - : _num_verts(num_verts), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _chunk_size(chunk_size), _degree_d2(degree_d2) + non_const_1d_size_type_view_t °ree_d2) + : _num_verts(num_verts) + , _idx(xadj) + , _adj(adj) + , _t_idx(t_xadj) + , _t_adj(t_adj) + , _degree_d2(degree_d2) { } KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t chunk_id) const + void operator()(const nnz_lno_t vid) const { - // Loop over vertices in chunks - for(nnz_lno_t chunk_idx = 0; chunk_idx < _chunk_size; chunk_idx++) - { - nnz_lno_t vid = chunk_id * _chunk_size + chunk_idx; - if(vid < _num_verts) - { - const size_type vid_d1_adj_begin = _idx(vid); - const size_type vid_d1_adj_end = _idx(vid + 1); - - // Loop over neighbors of vid (distance-1 from vid) - for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - const size_type vid_d2_adj_begin = _t_idx(vid_d1); - const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); - const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; - _degree_d2(vid) += degree_vid_d1; - } // for vid_d1_adj ... - } // if vid < nv ... - } // for chunk_idx ... - } // operator() (end) - }; // struct functorCalculateD2Degree (end) - // EXPERIMENTAL End + const size_type vid_d1_adj_begin = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); + // Loop over neighbors of vid (distance-1 from vid) + for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; + _degree_d2(vid) += degree_vid_d1; + } // for vid_d1_adj ... + } // operator() (end) + }; // struct functorCalculateD2Degree (end) From 108ff79fd65f985390e611148f1a67aa26a9bc8a Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 15 Aug 2018 16:59:22 -0600 Subject: [PATCH 044/190] D2 Coloring DateTime Reporting Added a Date/Time (ISO8601) field to the output reporting for D2 Coloring testing. --- perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 5d240878c0..585ab56b25 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -48,10 +48,12 @@ #include #include +#include #include #include #include +#include #include #include #include @@ -312,6 +314,9 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + // Get Date/Time stamps of start to use later when printing out summary data. + auto t = std::time(nullptr); + auto tm = *std::localtime(&t); // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' @@ -522,6 +527,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Summary" << std::endl << "-------" << std::endl + << " Date/Time : " << std::put_time(&tm, "%FT%T%z") << std::endl << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl << " Filename : " << a_mtx_bin_file << std::endl << " Num Verts : " << crsGraph.numRows() << std::endl @@ -550,6 +556,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEHDR" << "," << "Filename" << "," << "Host" + << "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -572,6 +579,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEDATA" << "," << a_mtx_bin_file << "," << hostname + << "," << std::put_time(&tm, "%FT%T%z") << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -594,6 +602,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVHISTHDR" << "," << "Filename" << "," << "Host" + << "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -606,6 +615,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVHISTDATA" << "," << a_mtx_bin_file << "," << hostname + << "," << std::put_time(&tm, "%FT%T%z") << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() From 7930c0fe37e696b87f208ab434e1e1052a8ddb5c Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 28 Aug 2018 11:48:51 -0600 Subject: [PATCH 045/190] Tighten up max d2 degree calculation Initial use of Hashmap_Accumulator to identify the max "unique" distance-2 degree in the graph. --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 6 +- src/graph/KokkosGraph_Distance2Color.hpp | 5 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 855 ++++++++++-------- 3 files changed, 483 insertions(+), 383 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 585ab56b25..2bf0b0b4b3 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -478,11 +478,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); size_t degree_d2_max=0; - size_t degree_d2_sum=0; computeDistance2Degree(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, - degree_d2_dist, degree_d2_max, degree_d2_sum); + degree_d2_dist, degree_d2_max); double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); @@ -536,7 +535,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Algorithm : " << label_algorithm << std::endl << "Graph Stats" << std::endl << " Degree D2 Max : " << degree_d2_max << std::endl - << " Degree D2 Sum : " << degree_d2_sum << std::endl << "Overall Time/Stats" << std::endl << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl @@ -572,7 +570,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Avg Colors" << "," << "Avg Num Phases" << "," << "Degree D2 Max" - << "," << "Degree D2 Sum" << "," << "Validation" << std::endl; @@ -595,7 +592,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << avg_colors << "," << avg_phases << "," << degree_d2_max - << "," << degree_d2_sum << "," << all_results_valid_str << std::endl; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 34ffe6a0ef..0bdb1adaa5 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -173,13 +173,12 @@ void computeDistance2Degree(KernelHandle *handle, lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries, typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, - size_t& degree_d2_max, - size_t& degree_d2_sum) + size_t& degree_d2_max) { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.calculate_d2_degree(degree_d2_dist, degree_d2_max, degree_d2_sum); + gc.calculate_d2_degree(degree_d2_dist, degree_d2_max); } diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 50f4a7a178..9e2bb54370 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -44,12 +44,18 @@ #include #include -#include #include #include #include +#include + +#include +#include +#include + #include -#include + +//#include #include "KokkosGraph_GraphColor.hpp" #include "KokkosGraph_GraphColorHandle.hpp" @@ -68,6 +74,7 @@ namespace Impl { #define WCMCLEN_EXPERIMENTAL 0 + /*! * \brief Distance-2 Graph Coloring class * @@ -116,6 +123,9 @@ class GraphColorD2 //typedef Kokkos::View non_const_1d_size_type_view_t; typedef typename HandleType::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; + // For HashmapAccumulator + typedef typename KokkosKernels::Impl::UniformMemoryPool pool_memory_space_t; // EXPERIMENTAL + typedef long long int bit_64_forbidden_t; protected: @@ -308,7 +318,7 @@ class GraphColorD2 total_time += time; std::cout << "\tIteration: " << iter << std::endl << "\t - Time speculative greedy phase : " << time << std::endl; - // << "\t - Num Uncolored : " << numUncolored << std::endl; + std::cout << "\t - Num Uncolored : " << numUncolored << std::endl; gc_handle->add_to_overall_coloring_time_phase1(time); @@ -339,7 +349,8 @@ class GraphColorD2 { time = timer.seconds(); total_time += time; - std::cout << "\t - Time conflict detection " << " : " << time << std::endl; + std::cout << "\t - Time conflict detection : " << time << std::endl; + std::cout << "\t - Num Uncolored : " << numUncolored << std::endl; gc_handle->add_to_overall_coloring_time_phase2(time); timer.reset(); } @@ -482,6 +493,87 @@ class GraphColorD2 + /** + * Calculate the distance-2 degree of all the vertices in the graph. + * + * @param degree_d2 : A mutable view of size |V| + * @param degree_d2_max : Saves the max distance-2 degree value in. + * @param degree_d2_sum : Saves the sum of the distance-2 degrees + * of all vertices. + * + * // EXPERIMENTAL / SCAFFOLDING / WCMCLEN / + */ + void calculate_d2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) + { + // Vertex group chunking + nnz_lno_t v_chunk_size = this->_chunkSize; + nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; + + nnz_lno_t max_d1_degree = 0; + this->calculate_max_degree(max_d1_degree); + + // Round up hash_size to next power of two + nnz_lno_t hash_size = 1; + while(hash_size < max_d1_degree) { hash_size *= 2; } + + // Max Nonzeros in D2 context can be max_degree(G)^2 + nnz_lno_t max_nonzeros = max_d1_degree * max_d1_degree; + + // Determine how much we'd need for UniformMemoryPool + nnz_lno_t mem_chunk_size = hash_size; // For hash indices + mem_chunk_size += hash_size; // For hash begins + mem_chunk_size += max_nonzeros; // For hash nexts + mem_chunk_size += max_nonzeros; // For hash keys + // nnz_lno_t mem_chunk_size += max_nonzeros; // For hash_values +/* + std::cout << "num_verts = " << this->nv << std::endl; + std::cout << "v_chunk_size = " << v_chunk_size << std::endl; + std::cout << "v_num_chunks = " << v_num_chunks << std::endl; + std::cout << "max_d1_degree = " << max_d1_degree << std::endl; + std::cout << "mem_chunk_size = " << mem_chunk_size << std::endl; + std::cout << "hash_size = " << hash_size << std::endl; +*/ + // HashmapAccumulator requires a memory Pool + KokkosKernels::Impl::PoolType my_pool_type = KokkosKernels::Impl::OneThread2OneChunk; + pool_memory_space_t m_space(v_num_chunks, mem_chunk_size, -1, my_pool_type); + +/* + std::cout << std::endl << "Memory Pool:" << std::endl; + m_space.print_memory_pool(true); +*/ + + functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, v_chunk_size, degree_d2, m_space, hash_size, max_nonzeros); + Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, v_num_chunks), calculateD2Degree); + + // Compute maximum d2 degree + size_t _degree_d2_max = 0; + Kokkos::parallel_reduce("Max D2 Degree", + this->nv, + KOKKOS_LAMBDA(const size_t &i, size_t &lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, + Kokkos::Max(_degree_d2_max)); + degree_d2_max = _degree_d2_max; + } + + + /** + * Compute the maximum distance-1 degree. + */ + void calculate_max_degree(nnz_lno_t& max_degree) + { + nnz_lno_t tmp_max_degree = 0; + Kokkos::parallel_reduce("Max Degree", + this->nv, + KOKKOS_LAMBDA(const nnz_lno_t& vid, nnz_lno_t& lmax) + { + const nnz_lno_t degree = this->xadj(vid+1) - this->xadj(vid); + lmax = degree > lmax ? degree : lmax; + }, + Kokkos::Max(tmp_max_degree)); + max_degree = tmp_max_degree; + } + + + private: @@ -525,15 +617,15 @@ class GraphColorD2 switch(this->gc_handle->get_coloring_algo_type()) { // Single level parallelism on chunks - // 1. [P] loop over chunks of vertices - // 2. [S] loop over vertices in chunks + // 1. [P] loop over vertices + // 2. [S] loop over color offset blocks // 3. [S] loop over vertex neighbors // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2: case COLORING_D2_VB: { - functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); + functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; @@ -634,15 +726,14 @@ class GraphColorD2 break; // One level Perallelism, BIT Array for coloring - // 1. [P] loop over chunks of vertices - // 2. [S] loop over vertices in chunks - // 3. [S] loop over color offset blocks - // 4. [S] loop over vertex neighbors - // 5. [S] loop over vertex neighbors of neighbors + // 1. [P] loop over vertices + // 2. [S] loop over color offset blocks + // 3. [S] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VB_BIT: { - functorGreedyColorVB_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); + functorGreedyColorVB_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; @@ -687,36 +778,27 @@ class GraphColorD2 nnz_lno_temp_work_view_t current_vertexList_, nnz_lno_t current_vertexListLength_) { - nnz_lno_t chunkSize_ = this->_chunkSize; - - if(current_vertexListLength_ < 100 * chunkSize_) - { - chunkSize_ = 1; - } - - const size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; - // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) { // One level Perallelism, BIT Array for coloring + edge filtering - // 1. [P] loop over chunks of vertices - // 2. [S] loop over vertices in chunks - // 3. [S] loop over color offset blocks - // 4. [S] loop over vertex neighbors - // 5. [S] loop over vertex neighbors of neighbors + // 1. [P] loop over vertices + // 2. [S] loop over color offset blocks + // 3. [S] loop over vertex neighbors + // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VB_BIT_EF: { - functorGreedyColorVB_BIT_EF gc(this->nv, xadj_, adj_copy_, t_xadj_, t_adj_copy_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, num_chunks), gc); - //prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); + functorGreedyColorVB_BIT_EF gc( + this->nv, xadj_, adj_copy_, t_xadj_, t_adj_copy_, vertex_colors_, current_vertexList_, current_vertexListLength_); + Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); + // prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); } break; default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type or algorithm does not use Edge Filtering."); } - } // colorGreedyEF (end) + } // colorGreedyEF (end) @@ -947,10 +1029,8 @@ class GraphColorD2 const_clno_nnz_view_t t_adj_, color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) + nnz_lno_t vertexListLength) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) { } @@ -964,84 +1044,76 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_) const + void operator()(const nnz_lno_t vid) const { - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + // If vertex is not already colored... + if(_colors(vid) <= 0) { - if(vid_ * _chunkSize + ichunk < _vertexListLength) + bool foundColor = false; // Have we found a valid color? + + const size_type vid_adj_begin = _idx(vid); + const size_type vid_adj_end = _idx(vid + 1); + + // Use forbidden array to find available color. + // - should be small enough to fit into fast memory (use Kokkos memoryspace?) + bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + + // Do multiple passes if the forbidden array is too small. + // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations + // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. + // This could be as big as all the vertices in the graph if diameter(G)=2... + // * TODO: Determine if we can cap this at something lower than nv. + for(color_t offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid = _vertexList(vid_ * _chunkSize + ichunk); + // initialize + for(int i = 0; i < VB_D2_COLORING_FORBIDDEN_SIZE; i++) { forbidden[i] = false; } - // If vertex is not already colored... - if(_colors(vid) <= 0) + // Colors start at 1. 0 is special in that it means a vertex is uncolored. + // For the range 0..63 we mark forbidden[0] as true to take color 0 out of + // consideration. + if(0 == offset) { - bool foundColor = false; // Have we found a valid color? - - const size_type vid_adj_begin = _idx(vid); - const size_type vid_adj_end = _idx(vid + 1); + forbidden[0] = true; + } - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + // Check neighbors, fill forbidden array. + for(size_type vid_adj = vid_adj_begin; vid_adj < vid_adj_end; vid_adj++) + { + const nnz_lno_t vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - // Do multiple passes if the forbidden array is too small. - // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations - // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. - // This could be as big as all the vertices in the graph if diameter(G)=2... - // * TODO: Determine if we can cap this at something lower than nv. - for(color_t offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) + for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) { - // initialize - for(int i = 0; i < VB_D2_COLORING_FORBIDDEN_SIZE; i++) { forbidden[i] = false; } + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - // Colors start at 1. 0 is special in that it means a vertex is uncolored. - // For the range 0..63 we mark forbidden[0] as true to take color 0 out of - // consideration. - if(0 == offset) + // Skip distance-2-self-loops + if(vid_d2 != vid && vid_d2 < nv) { - forbidden[0] = true; - } + const color_t c = _colors(vid_d2); - // Check neighbors, fill forbidden array. - for(size_type vid_adj = vid_adj_begin; vid_adj < vid_adj_end; vid_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_adj); - const size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - - for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) + if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - - // Skip distance-2-self-loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - forbidden[c - offset] = true; - } - } - } // for vid_d1_adj... - } // for vid_adj... - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; + forbidden[c - offset] = true; } - } // for c... - } // for !foundColor... - } // if _colors(vid) <= 0... - } // if vid_ * _chunkSize... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVB (end) + } + } // for vid_d1_adj... + } // for vid_adj... + + // color vertex i with smallest available color (firstFit) + for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) + { + if(!forbidden[c]) + { + _colors(vid) = offset + c; + foundColor = true; + break; + } + } // for c... + } // for !foundColor... + } // if _colors(vid) <= 0... + } // operator() (end) + }; // struct functorGreedyColorVB (end) @@ -1059,7 +1131,6 @@ class GraphColorD2 color_view_type _colors; // vertex colors nnz_lno_temp_work_view_t _vertexList; // nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // functorGreedyColorVB_BIT(nnz_lno_t nv_, const_lno_row_view_t xadj_, @@ -1068,10 +1139,8 @@ class GraphColorD2 const_clno_nnz_view_t t_adj_, color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) + nnz_lno_t vertexListLength) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) { } @@ -1085,100 +1154,92 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_) const + void operator()(const nnz_lno_t vid) const { - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) + // If vertex is not colored yet... + if(_colors(vid) == 0) { - if(vid_ * _chunkSize + ichunk < _vertexListLength) + const size_type vid_adj_begin = _idx(vid); + const size_type vid_adj_end = _idx(vid + 1); + + bool foundColor = false; + for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid = _vertexList(vid_ * _chunkSize + ichunk); + // Forbidden colors + // - single long int for forbidden colors + bit_64_forbidden_t forbidden = 0; - // If vertex is not colored yet... - if(_colors(vid) == 0) + // If all available colors for this range are unavailable we can break out of the nested loops + bool break_out = false; + + // Loop over distance-1 neighbors of vid + for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) { - const size_type vid_adj_begin = _idx(vid); - const size_type vid_adj_end = _idx(vid + 1); + const nnz_lno_t vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) + // Loop over distance-2 neighbors of vid + for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) { - // Forbidden colors - // - single long int for forbidden colors - bit_64_forbidden_t forbidden = 0; + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - // If all available colors for this range are unavailable we can break out of the nested loops - bool break_out = false; - - // Loop over distance-1 neighbors of vid - for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) + // Ignore Distance-2 Self Loops + if(vid_d2 != vid && vid_d2 < nv) { - const nnz_lno_t vid_d1 = _adj(vid_adj); - const size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const color_t color = _colors(vid_d2); + const color_t color_offset = color - offset; - // Loop over distance-2 neighbors of vid - for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + // if color is within the current range, or if its color is in a previously traversed + // range + if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - - // Ignore Distance-2 Self Loops - if(vid_d2 != vid && vid_d2 < nv) + // if it is in the current range, then add the color to the banned colors + if(color > offset) { - const color_t color = _colors(vid_d2); - const color_t color_offset = color - offset; + // convert color to bit representation + bit_64_forbidden_t ban_color_bit = 1; - // if color is within the current range, or if its color is in a previously traversed - // range - if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - // if it is in the current range, then add the color to the banned colors - if(color > offset) - { - // convert color to bit representation - bit_64_forbidden_t ban_color_bit = 1; - - ban_color_bit = ban_color_bit << (color_offset - 1); + ban_color_bit = ban_color_bit << (color_offset - 1); - // add it to forbidden colors - forbidden = forbidden | ban_color_bit; - - // if there are no available colors in this range then exit early, - // no need to traverse the rest. - if(0 == ~forbidden) - { - break_out = true; - } - } // if color > offset ... - } // if color && color_offset ... - } // if vid_d2 ... - } // for vid_d1_adj ... - } // for vid_adj ... - forbidden = ~(forbidden); + // add it to forbidden colors + forbidden = forbidden | ban_color_bit; - // check if an available color exists. - if(forbidden) - { - color_t val = 1; + // if there are no available colors in this range then exit early, + // no need to traverse the rest. + if(0 == ~forbidden) + { + break_out = true; + } + } // if color > offset ... + } // if color && color_offset ... + } // if vid_d2 ... + } // for vid_d1_adj ... + } // for vid_adj ... + forbidden = ~(forbidden); + + // check if an available color exists. + if(forbidden) + { + color_t val = 1; - // if there is an available color, choose the first color, using 2s complement. - bit_64_forbidden_t new_color = forbidden & (-forbidden); + // if there is an available color, choose the first color, using 2s complement. + bit_64_forbidden_t new_color = forbidden & (-forbidden); - // convert it back to decimal color. - while((new_color & 1) == 0) - { - ++val; - new_color = new_color >> 1; - } - _colors(vid) = val + offset; - foundColor = true; - break; - } - } // for !foundColor - } // if _colors(vid)==0 - } // if vid_ * _chunkSize ... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVB_BIT (end) + // convert it back to decimal color. + while((new_color & 1) == 0) + { + ++val; + new_color = new_color >> 1; + } + _colors(vid) = val + offset; + foundColor = true; + break; + } + } // for !foundColor + } // if _colors(vid)==0 + } // operator() (end) + }; // struct functorGreedyColorVB_BIT (end) @@ -1331,7 +1392,7 @@ class GraphColorD2 */ struct functorGreedyColorVB_BIT_EF { - nnz_lno_t _nv; // num vertices + nnz_lno_t _nv; // num vertices const_lno_row_view_t _idx; // vertex degree list nnz_lno_temp_work_view_t _adj; // vertex adjacency list (mutable) const_clno_row_view_t _t_idx; // transpose vertex degree list @@ -1339,7 +1400,6 @@ class GraphColorD2 color_view_type _colors; // vertex colors nnz_lno_temp_work_view_t _vertexList; // nnz_lno_t _vertexListLength; // - nnz_lno_t _chunk_size; // functorGreedyColorVB_BIT_EF(nnz_lno_t nv, const_lno_row_view_t xadj, @@ -1348,10 +1408,8 @@ class GraphColorD2 non_const_clno_nnz_view_t t_adj, color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunk_size) - : _nv(nv), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunk_size(chunk_size) + nnz_lno_t vertexListLength) + : _nv(nv), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) { } @@ -1365,134 +1423,124 @@ class GraphColorD2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t chunk_idx) const + void operator()(const nnz_lno_t vid) const { - for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) + // If vertex is not colored yet.. + if(_colors(vid) == 0) { - const nnz_lno_t vid_idx = chunk_idx * _chunk_size + ichunk; + size_type vid_adj_begin = _idx(vid); + size_type vid_adj_end = _idx(vid + 1); - if(vid_idx < _vertexListLength) + bool foundColor = false; + for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid = _vertexList(vid_idx); + // Forbidden colors + // - single long int for forbidden colors + bit_64_forbidden_t forbidden = 0; - // If vertex is not colored yet.. - if(_colors(vid) == 0) + // If all available colors for this range are unavailable we can break out of the nested loops + bool offset_colors_full = false; + + // Loop over distance-1 neighbors of vid + for(size_type vid_adj = vid_adj_begin; !offset_colors_full && vid_adj < vid_adj_end; ++vid_adj) { - size_type vid_adj_begin = _idx(vid); - size_type vid_adj_end = _idx(vid + 1); + const nnz_lno_t vid_d1 = _adj(vid_adj); - bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - // Forbidden colors - // - single long int for forbidden colors - bit_64_forbidden_t forbidden = 0; + size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; + size_type num_vid_d2_colored_in_range = 0; - // If all available colors for this range are unavailable we can break out of the nested loops - bool offset_colors_full = false; + // Store the maximum color value found in the vertices adjacent to vid_d1 + color_t max_color_adj_to_d1 = 0; - // Loop over distance-1 neighbors of vid - for(size_type vid_adj = vid_adj_begin; !offset_colors_full && vid_adj < vid_adj_end; ++vid_adj) - { - const nnz_lno_t vid_d1 = _adj(vid_adj); + // Loop over distance-2 neighbors of vid + for(size_type vid_d1_adj = vid_d1_adj_begin; !offset_colors_full && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; - size_type num_vid_d2_colored_in_range = 0; + // Ignore Distance-2 Self Loops + if(vid_d2 != vid && vid_d2 < _nv) + { + color_t color = _colors(vid_d2); + color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. - // Store the maximum color value found in the vertices adjacent to vid_d1 - color_t max_color_adj_to_d1 = 0; + // Update maximum color adjacent to vid_d1 found so far. + max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; - // Loop over distance-2 neighbors of vid - for(size_type vid_d1_adj = vid_d1_adj_begin; !offset_colors_full && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + // if color is within the current range, or if its color is in a previously traversed + // range + if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + num_vid_d2_colored_in_range++; - // Ignore Distance-2 Self Loops - if(vid_d2 != vid && vid_d2 < _nv) + // if it is in the current range, then add the color to the banned colors + if(color > offset) { - color_t color = _colors(vid_d2); - color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. + // convert color to bit representation + bit_64_forbidden_t ban_color_bit = 1; - // Update maximum color adjacent to vid_d1 found so far. - max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; + ban_color_bit = ban_color_bit << (color_offset - 1); - // if color is within the current range, or if its color is in a previously traversed - // range - if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - num_vid_d2_colored_in_range++; + // add it to forbidden colors + forbidden = forbidden | ban_color_bit; - // if it is in the current range, then add the color to the banned colors - if(color > offset) - { - // convert color to bit representation - bit_64_forbidden_t ban_color_bit = 1; - - ban_color_bit = ban_color_bit << (color_offset - 1); - - // add it to forbidden colors - forbidden = forbidden | ban_color_bit; - - // if there are no available colors in this range then exit early, - // no need to traverse the rest b/c they contribute no new information - // at this offset. - if(0 == ~forbidden) - { - offset_colors_full = true; - // Note: with edge-filtering, this can short-circuit the loop over all - // neighbors of VID and will reduce the number of filtered edges. - } - } // if color > offset - } // if color && color_offset - } // if vid_d2 != vid ... - else - { - // If there's a self-loop then we should increment our 'colored in range' so we don't - // block filtering since we know there must be a (v2,v1) edge - num_vid_d2_colored_in_range++; - } - } // for vid_d1_adj ... + // if there are no available colors in this range then exit early, + // no need to traverse the rest b/c they contribute no new information + // at this offset. + if(0 == ~forbidden) + { + offset_colors_full = true; + // Note: with edge-filtering, this can short-circuit the loop over all + // neighbors of VID and will reduce the number of filtered edges. + } + } // if color > offset + } // if color && color_offset + } // if vid_d2 != vid ... + else + { + // If there's a self-loop then we should increment our 'colored in range' so we don't + // block filtering since we know there must be a (v2,v1) edge + num_vid_d2_colored_in_range++; + } + } // for vid_d1_adj ... - // Edge filtering on the neighbors of vid. We can only do this if ALL neighbors of vid_d1 - // have been visited and if all were colored in current offset range or lower. - if(degree_vid_d1 == num_vid_d2_colored_in_range) - { - if(vid_adj_begin > vid_adj) - { - _adj(vid_adj) = _adj(vid_adj_begin); - _adj(vid_adj_begin) = vid_d1; - } - vid_adj_begin++; - } + // Edge filtering on the neighbors of vid. We can only do this if ALL neighbors of vid_d1 + // have been visited and if all were colored in current offset range or lower. + if(degree_vid_d1 == num_vid_d2_colored_in_range) + { + if(vid_adj_begin > vid_adj) + { + _adj(vid_adj) = _adj(vid_adj_begin); + _adj(vid_adj_begin) = vid_d1; + } + vid_adj_begin++; + } - } // for vid_adj - forbidden = ~(forbidden); + } // for vid_adj + forbidden = ~(forbidden); - // check if an available color exists. - if(forbidden) - { - // if there is an available color, choose the first color, using 2s complement. - bit_64_forbidden_t new_color = forbidden & (-forbidden); - color_t val = 1; + // check if an available color exists. + if(forbidden) + { + // if there is an available color, choose the first color, using 2s complement. + bit_64_forbidden_t new_color = forbidden & (-forbidden); + color_t val = 1; - // convert it back to decimal color. - while((new_color & 1) == 0) - { - ++val; - new_color = new_color >> 1; - } - _colors(vid) = val + offset; - foundColor = true; - break; - } - } // for offset=0... - } // if _colors(vid)==0 - } // if vid_ * _chunkSize ... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVB_BIT_EF (end) + // convert it back to decimal color. + while((new_color & 1) == 0) + { + ++val; + new_color = new_color >> 1; + } + _colors(vid) = val + offset; + foundColor = true; + break; + } + } // for offset=0... + } // if _colors(vid)==0 + } // operator() (end) + }; // struct functorGreedyColorVB_BIT_EF (end) @@ -2190,14 +2238,15 @@ class GraphColorD2 */ struct functorVerifyDistance2Coloring { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - non_const_1d_bool_view_t _flags; // [0]: valid or not? [1]=true means something is uncolored. [2]=true means something has distance-2 neighbor of same color - nnz_lno_t _chunkSize; // + nnz_lno_t nv; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + non_const_1d_bool_view_t + _flags; // [0]: valid or not? [1]=true means something is uncolored. [2]=true means something has distance-2 neighbor of same color + nnz_lno_t _chunkSize; // functorVerifyDistance2Coloring(nnz_lno_t nv_, const_lno_row_view_t xadj_, @@ -2207,14 +2256,7 @@ class GraphColorD2 color_view_type colors, non_const_1d_bool_view_t flags, nnz_lno_t chunkSize) - : nv(nv_) - , _idx(xadj_) - , _adj(adj_) - , _t_idx(t_xadj_) - , _t_adj(t_adj_) - , _colors(colors) - , _flags(flags) - , _chunkSize(chunkSize) + : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _flags(flags), _chunkSize(chunkSize) { } @@ -2284,94 +2326,157 @@ class GraphColorD2 if(has_color_bigger_than_num_verts) Kokkos::atomic_fetch_or(&_flags[3], has_color_bigger_than_num_verts); } // operator() - }; // struct functorGreedyColorVB (end) - - - - /** - * Calculate the distance-2 degree of all the vertices in the graph. - * - * @param degree_d2 : A mutable view of size |V| - * @param degree_d2_max : Saves the max distance-2 degree value in. - * @param degree_d2_sum : Saves the sum of the distance-2 degrees - * of all vertices. - */ - void calculate_d2_degree(non_const_1d_size_type_view_t& degree_d2, size_t& degree_d2_max, size_t& degree_d2_sum) - { - functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, degree_d2); - Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, this->nv), calculateD2Degree); + }; // struct functorVerifyDistance2Coloring (end) - // Compute maximum d2 degree - size_t _degree_d2_max = 0; - Kokkos::parallel_reduce("Max D2 Degree", - this->nv, - KOKKOS_LAMBDA(const size_t &i, size_t &lmax) - { - lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; - }, - Kokkos::Max(_degree_d2_max)); - degree_d2_max = _degree_d2_max; - // Compute the sum of all d2 degrees - size_t _degree_d2_sum = 0; - Kokkos::parallel_reduce("Sum D2 Degree", - this->nv, - KOKKOS_LAMBDA(const size_t &i, size_t &lsum) - { - lsum += degree_d2(i); - }, - Kokkos::Sum(_degree_d2_sum)); - degree_d2_sum = _degree_d2_sum; - } /** - * functorVerifyDistance2Coloring - * - Validate correctness of the distance-2 coloring + * functorCalculateD2Degree */ struct functorCalculateD2Degree { - nnz_lno_t _num_verts; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + nnz_lno_t _num_verts; // num vertices + const_lno_row_view_t _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + nnz_lno_t _chunk_size; non_const_1d_size_type_view_t _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) - functorCalculateD2Degree(nnz_lno_t num_verts, - const_lno_row_view_t xadj, - const_lno_nnz_view_t adj, - const_clno_row_view_t t_xadj, - const_clno_nnz_view_t t_adj, - non_const_1d_size_type_view_t °ree_d2) + // EXPERIMENTAL BEGIN + pool_memory_space_t _m_space; + const nnz_lno_t _hash_size; + const nnz_lno_t _max_nonzeros; + + Kokkos::Experimental::UniqueToken tokens; + // EXPERIMENTAL END + + functorCalculateD2Degree( nnz_lno_t num_verts + , const_lno_row_view_t xadj + , const_lno_nnz_view_t adj + , const_clno_row_view_t t_xadj + , const_clno_nnz_view_t t_adj + , nnz_lno_t chunk_size + , non_const_1d_size_type_view_t °ree_d2 + , pool_memory_space_t m_space + , const nnz_lno_t hash_size + , const nnz_lno_t max_nonzeros + ) : _num_verts(num_verts) , _idx(xadj) , _adj(adj) , _t_idx(t_xadj) , _t_adj(t_adj) + , _chunk_size(chunk_size) , _degree_d2(degree_d2) + , _m_space(m_space) + , _hash_size(hash_size) + , _max_nonzeros(max_nonzeros) { } + KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid) const + void operator()(const nnz_lno_t chunk_id) const { - const size_type vid_d1_adj_begin = _idx(vid); - const size_type vid_d1_adj_end = _idx(vid + 1); +#if 1 + // EXPERIMENTAL + // Get a unique token since we aren't using TeamPolicy here + // (for UniformMemoryPool that the HashmapAccumulator requires) + auto tid = tokens.acquire(); + + volatile nnz_lno_t * tmp = NULL; + while(NULL==tmp) + { + tmp = (volatile nnz_lno_t*)(_m_space.allocate_chunk(tid)); + } + + KokkosKernels::Experimental::HashmapAccumulator hash_map; + + nnz_lno_t *globally_used_hash_indices = (nnz_lno_t*) tmp; + tmp += _hash_size; + hash_map.hash_begins = (nnz_lno_t *)(tmp); + tmp += _hash_size; + hash_map.hash_nexts = (nnz_lno_t *)(tmp); + tmp += _max_nonzeros; + hash_map.keys = (nnz_lno_t *)(tmp); + hash_map.hash_key_size = _hash_size; + hash_map.max_value_size = _hash_size; - // Loop over neighbors of vid (distance-1 from vid) - for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + nnz_lno_t pow2_hash_func = _hash_size-1; + +#endif + for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - const size_type vid_d2_adj_begin = _t_idx(vid_d1); - const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); - const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; - _degree_d2(vid) += degree_vid_d1; - } // for vid_d1_adj ... - } // operator() (end) - }; // struct functorCalculateD2Degree (end) + nnz_lno_t vid = chunk_id * _chunk_size + ichunk; + + if(vid >= _num_verts) continue; + + nnz_lno_t used_hash_size = 0; + nnz_lno_t globally_used_hash_count = 0; + + const size_type vid_d1_adj_begin = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); + + // Loop over neighbors of vid (distance-1 from vid) + for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + { + const nnz_lno_t vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + + // EXPERIMENTAL BEGIN + for(size_type vid_d2_adj = vid_d2_adj_begin; vid_d2_adj < vid_d2_adj_end; ++vid_d2_adj) + { + + const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + + nnz_lno_t hash = vid_d2 & pow2_hash_func; + +#if 1 + int r = hash_map.sequential_insert_into_hash_TrackHashes(hash, + vid_d2, + &used_hash_size, + hash_map.max_value_size, + &globally_used_hash_count, + globally_used_hash_indices); + + // TODO: Check r to make sure the insertion was successful. + if(r != 0) + { + // Do something if we couldn't insert... + } +#endif + } + + // EXPERIMENTAL END + +// const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; +// _degree_d2(vid) += degree_vid_d1; + } // for vid_d1_adj ... + + // EXPERIMENTAL BEGIN +#if 1 +// std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; + _degree_d2(vid) = used_hash_size; + + // Clear the Begins values. + for(nnz_lno_t i=0; i < globally_used_hash_count; i++) + { + nnz_lno_t dirty_hash = globally_used_hash_indices[i]; + hash_map.hash_begins[dirty_hash] = -1; + } +#endif + // EXPERIMENTAL END + + + } // for ichunk ... + _m_space.release_chunk(globally_used_hash_indices); + } // operator() (end) + }; // struct functorCalculateD2Degree (end) }; // end class GraphColorD2 From 920042d3da2d86e8b30e891ccccec1d79cc2b7c6 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Fri, 14 Sep 2018 16:14:28 -0600 Subject: [PATCH 046/190] D2 Color: HashmapAccumulator working for unique-degree calculation --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 35 +++++++------------ 1 file changed, 12 insertions(+), 23 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 9e2bb54370..fab199afd7 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -2380,10 +2380,9 @@ class GraphColorD2 KOKKOS_INLINE_FUNCTION void operator()(const nnz_lno_t chunk_id) const { -#if 1 + #if 1 // EXPERIMENTAL - // Get a unique token since we aren't using TeamPolicy here - // (for UniformMemoryPool that the HashmapAccumulator requires) + // Get a unique token since we aren't using TeamPolicy (for UniformMemoryPool, that the HashmapAccumulator requires) auto tid = tokens.acquire(); volatile nnz_lno_t * tmp = NULL; @@ -2405,8 +2404,8 @@ class GraphColorD2 hash_map.max_value_size = _hash_size; nnz_lno_t pow2_hash_func = _hash_size-1; + #endif -#endif for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) { nnz_lno_t vid = chunk_id * _chunk_size + ichunk; @@ -2434,7 +2433,7 @@ class GraphColorD2 nnz_lno_t hash = vid_d2 & pow2_hash_func; -#if 1 + #if 1 int r = hash_map.sequential_insert_into_hash_TrackHashes(hash, vid_d2, &used_hash_size, @@ -2447,18 +2446,14 @@ class GraphColorD2 { // Do something if we couldn't insert... } -#endif + #endif } - // EXPERIMENTAL END - -// const size_type degree_vid_d1 = vid_d2_adj_end - vid_d2_adj_begin; -// _degree_d2(vid) += degree_vid_d1; } // for vid_d1_adj ... // EXPERIMENTAL BEGIN -#if 1 -// std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; + #if 1 + //std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; _degree_d2(vid) = used_hash_size; // Clear the Begins values. @@ -2467,19 +2462,13 @@ class GraphColorD2 nnz_lno_t dirty_hash = globally_used_hash_indices[i]; hash_map.hash_begins[dirty_hash] = -1; } -#endif + #endif // EXPERIMENTAL END - - - - } // for ichunk ... - + } // for ichunk ... _m_space.release_chunk(globally_used_hash_indices); - } // operator() (end) - }; // struct functorCalculateD2Degree (end) - -}; // end class GraphColorD2 - + } // operator() (end) + }; // struct functorCalculateD2Degree (end) +}; // end class GraphColorD2 } // namespace Impl From 9a5eed1d49fe2e129514f54caf072ee3cf8d71b1 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 17 Sep 2018 13:21:24 -0600 Subject: [PATCH 047/190] D2 Coloring: std::put_time isn't supported on intel C++ 17.0.x --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 21 ++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 2bf0b0b4b3..ce8fe4de1e 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -288,6 +288,17 @@ namespace KokkosKernels { namespace Experiment { +std::string getCurrentDateTimeStr() +{ + // Note: This could be replaced with `std::put_time(&tm, "%FT%T%z")` but std::put_time isn't + // supported on the intel C++ compilers as of v. 17.0.x + time_t now = time(0); + char output[100]; + std::strftime(output, sizeof(output), "%FT%T%Z", std::localtime(&now)); + return output; +} + + template void run_experiment(crsGraph_t crsGraph, Parameters params) { @@ -524,9 +535,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) if(!all_results_valid) all_results_valid_str = "FAILED"; + std::string currentDateTimeStr = getCurrentDateTimeStr(); + std::cout << "Summary" << std::endl << "-------" << std::endl - << " Date/Time : " << std::put_time(&tm, "%FT%T%z") << std::endl + << " Date/Time : " << currentDateTimeStr << std::endl << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl << " Filename : " << a_mtx_bin_file << std::endl << " Num Verts : " << crsGraph.numRows() << std::endl @@ -576,7 +589,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEDATA" << "," << a_mtx_bin_file << "," << hostname - << "," << std::put_time(&tm, "%FT%T%z") + << "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -611,7 +624,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVHISTDATA" << "," << a_mtx_bin_file << "," << hostname - << "," << std::put_time(&tm, "%FT%T%z") + << "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -823,8 +836,6 @@ void run_multi_mem_experiment(Parameters params) - - int main(int argc, char *argv[]) { KokkosKernels::Experiment::Parameters params; From a621d1f59c4e29e20628239670be64753310414e Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 17 Sep 2018 15:04:20 -0600 Subject: [PATCH 048/190] D2 color: add timing for d2 degree calculation --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 26 +++++++++++++------ 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index ce8fe4de1e..34747d6252 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -326,8 +326,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; // Get Date/Time stamps of start to use later when printing out summary data. - auto t = std::time(nullptr); - auto tm = *std::localtime(&t); + //auto t = std::time(nullptr); + //auto tm = *std::localtime(&t); // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' @@ -485,6 +485,12 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // ------------------------------------------ // Compute Distance 2 Degree Stats // ------------------------------------------ + std::cout << "Compute Distance-2 Degree " << std::endl; + + double time_d2_degree; + Kokkos::Impl::Timer timer; + timer.reset(); + typedef typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); @@ -494,6 +500,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) crsGraph.row_map, crsGraph.entries, degree_d2_dist, degree_d2_max); + time_d2_degree = timer.seconds(); + double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); @@ -539,7 +547,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Summary" << std::endl << "-------" << std::endl - << " Date/Time : " << currentDateTimeStr << std::endl + //<< " Date/Time : " << currentDateTimeStr << std::endl << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl << " Filename : " << a_mtx_bin_file << std::endl << " Num Verts : " << crsGraph.numRows() << std::endl @@ -548,6 +556,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Algorithm : " << label_algorithm << std::endl << "Graph Stats" << std::endl << " Degree D2 Max : " << degree_d2_max << std::endl + << " Degree D2 Time : " << time_d2_degree << std::endl << "Overall Time/Stats" << std::endl << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl @@ -567,7 +576,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEHDR" << "," << "Filename" << "," << "Host" - << "," << "DateTime" + //<< "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -580,6 +589,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Total Time CG" << "," << "Total Time FC" << "," << "Total Time RC" + << "," << "Time D2 Degree" << "," << "Avg Colors" << "," << "Avg Num Phases" << "," << "Degree D2 Max" @@ -589,7 +599,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEDATA" << "," << a_mtx_bin_file << "," << hostname - << "," << currentDateTimeStr + //<< "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -602,6 +612,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << total_time_color_greedy << "," << total_time_find_conflicts << "," << total_time_resolve_conflicts + << "," << time_d2_degree << "," << avg_colors << "," << avg_phases << "," << degree_d2_max @@ -611,7 +622,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVHISTHDR" << "," << "Filename" << "," << "Host" - << "," << "DateTime" + //<< "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -620,11 +631,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Histogram: 1 .. N" << std::endl; - std::cout << "CSVHISTDATA" << "," << a_mtx_bin_file << "," << hostname - << "," << currentDateTimeStr + //<< "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() From dda021c63524473644a6450eb2f472b2701c4f4d Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 18 Sep 2018 12:14:20 -0600 Subject: [PATCH 049/190] D2 Coloring: Try increasing the hash_size argument to HashmapAccumulator --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index fab199afd7..72f3d6f284 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -509,12 +509,12 @@ class GraphColorD2 nnz_lno_t v_chunk_size = this->_chunkSize; nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; - nnz_lno_t max_d1_degree = 0; - this->calculate_max_degree(max_d1_degree); + // Get the maximum distance-1 degree + nnz_lno_t max_d1_degree = this->calculate_max_degree(); // Round up hash_size to next power of two nnz_lno_t hash_size = 1; - while(hash_size < max_d1_degree) { hash_size *= 2; } + while(hash_size < max_d1_degree*max_d1_degree) { hash_size *= 2; } // Max Nonzeros in D2 context can be max_degree(G)^2 nnz_lno_t max_nonzeros = max_d1_degree * max_d1_degree; @@ -558,18 +558,18 @@ class GraphColorD2 /** * Compute the maximum distance-1 degree. */ - void calculate_max_degree(nnz_lno_t& max_degree) + nnz_lno_t calculate_max_degree() const { - nnz_lno_t tmp_max_degree = 0; - Kokkos::parallel_reduce("Max Degree", + nnz_lno_t max_degree = 0; + Kokkos::parallel_reduce("Max D1 Degree", this->nv, KOKKOS_LAMBDA(const nnz_lno_t& vid, nnz_lno_t& lmax) { const nnz_lno_t degree = this->xadj(vid+1) - this->xadj(vid); lmax = degree > lmax ? degree : lmax; }, - Kokkos::Max(tmp_max_degree)); - max_degree = tmp_max_degree; + Kokkos::Max(max_degree)); + return max_degree; } @@ -2433,7 +2433,6 @@ class GraphColorD2 nnz_lno_t hash = vid_d2 & pow2_hash_func; - #if 1 int r = hash_map.sequential_insert_into_hash_TrackHashes(hash, vid_d2, &used_hash_size, @@ -2446,7 +2445,6 @@ class GraphColorD2 { // Do something if we couldn't insert... } - #endif } // EXPERIMENTAL END } // for vid_d1_adj ... From 58bfd0891aecc85db28abb3a4bf1a3492c586822 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 20 Sep 2018 11:25:04 -0600 Subject: [PATCH 050/190] update so siva and I can see the same thing --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 72f3d6f284..5cac6440da 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -501,13 +501,17 @@ class GraphColorD2 * @param degree_d2_sum : Saves the sum of the distance-2 degrees * of all vertices. * - * // EXPERIMENTAL / SCAFFOLDING / WCMCLEN / + * EXPERIMENTAL / SCAFFOLDING / WCMCLEN / */ void calculate_d2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) { // Vertex group chunking nnz_lno_t v_chunk_size = this->_chunkSize; - nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; + nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; // TODO: This probably needs fixing + + std::cout << ">>> this->nv = " << this->nv << std::endl; + std::cout << ">>> v_chunk_size = " << v_chunk_size << std::endl; + std::cout << ">>> v_num_chunks = " << v_num_chunks << std::endl; // Get the maximum distance-1 degree nnz_lno_t max_d1_degree = this->calculate_max_degree(); @@ -2393,15 +2397,24 @@ class GraphColorD2 KokkosKernels::Experimental::HashmapAccumulator hash_map; - nnz_lno_t *globally_used_hash_indices = (nnz_lno_t*) tmp; + // What is globally_used_hash_indices? + nnz_lno_t *globally_used_hash_indices = (nnz_lno_t *) tmp; tmp += _hash_size; + + // set up hash_begins hash_map.hash_begins = (nnz_lno_t *)(tmp); tmp += _hash_size; + + // set up hash_nexts hash_map.hash_nexts = (nnz_lno_t *)(tmp); tmp += _max_nonzeros; + + // set up hash_keys hash_map.keys = (nnz_lno_t *)(tmp); - hash_map.hash_key_size = _hash_size; - hash_map.max_value_size = _hash_size; + + // Set key and value sizes + hash_map.hash_key_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table (unused?) + hash_map.max_value_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table nnz_lno_t pow2_hash_func = _hash_size-1; #endif From 271a440febce648949f27fbfc65043af53bdc368 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Fri, 19 Oct 2018 13:14:11 -0600 Subject: [PATCH 051/190] KokkosBatched - householder transformation and apply methods Followed the implementation in libflame --- ...okkosBatched_ApplyHouseholder_Internal.hpp | 143 ++++++++++++++++++ .../KokkosBatched_Householder_Internal.hpp | 85 +++++++++++ 2 files changed, 228 insertions(+) create mode 100644 src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp create mode 100644 src/batched/KokkosBatched_Householder_Internal.hpp diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp new file mode 100644 index 0000000000..069bdd768a --- /dev/null +++ b/src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp @@ -0,0 +1,143 @@ +#ifndef __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialApplyLeftHouseholderInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(A2) = numRows(u2) + const int n, // n = NumCols(a1t) + const ValueType tau, + /* */ ValueType * u2, const int u2s, + /* */ ValueType * a1t, const int a1ts, + /* */ ValueType * A2, const int as0, const int as1, + /* */ ValueType * w1t) { + // apply a single householder transform H from the left to a row vector a1t + // and a matrix A2 + typedef ValueType value_type; + typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + + // compute the followings: + // a1t -= inv(tau)(a1t + u2'A2) + // A2 -= u2 inv(tau)(a1t + u2'A2) + + // w1t = a1t + for (int i=0;i::conj(u2[j*u2s]); + w1t[i] += tmp; + } + // gemv is not implemented for conjugate transpose; if use this, no support for complex + // SerialGemvInternal:: + // invoke(n, m, + // 1, + // A2, as1, as0, + // u2, u2s, + // 1, + // w1t, 1); + + // w1t /= tau + const value_type inv_tau = one/tau; + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(a1) + const int n, // n = NumRows(u2) = NumCols(A2) + const ValueType tau, + /* */ ValueType * u2, const int u2s, + /* */ ValueType * a1, const int a1s, + /* */ ValueType * A2, const int as0, const int as1, + /* */ ValueType * w1) { + // apply a single householder transform H from the left to a row vector a1t + // and a matrix A2 + typedef ValueType value_type; + typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + + // compute the followings: + // a1 -= inv(tau)(a1 + A2 u2) + // A2 -= inv(tau)(a1 + A2 u2) u2' + + // w1 = a1 + for (int i=0;i:: + // invoke(m, n, + // 1, + // A2, as0, as1, + // u2, u2s, + // 1, + // w1, 1); + + // w1t /= tau + const value_type inv_tau = one/tau; + for (int i=0;i::conj(u2[j*u2s]); + + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_Householder_Internal.hpp b/src/batched/KokkosBatched_Householder_Internal.hpp new file mode 100644 index 0000000000..e248588185 --- /dev/null +++ b/src/batched/KokkosBatched_Householder_Internal.hpp @@ -0,0 +1,85 @@ +#ifndef __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialLeftHouseholderInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m_x2, + /* */ ValueType * chi1, + /* */ ValueType * x2, const int x2s, + /* */ ValueType * tau) { + typedef ValueType value_type; + typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + + const mag_type zero(0); + const mag_type two(2); + const mag_type one_half(1.5); + const mag_type one(1); + const mag_type minus_one(-1); + + /// compute the 2norm of x2 + mag_type norm_x2(0); + for (int i=0;i::sqrt(norm_x2); + + /// if norm_x2 is zero, return with trivial values + if (norm_x2 == zero) { + *chi1 = -(*chi1); + *tau = one_half; + + return 0; + } + + /// compute magnitude of chi1, equal to norm2 of chi1 + const mag_type norm_chi1 = Kokkos::Details::ArithTraits::abs(*chi1); + + /// compute 2 norm of x using norm_chi1 and norm_x2 + const mag_type norm_x = Kokkos::Details::ArithTraits::sqrt(norm_x2*norm_x2 + norm_chi1*norm_chi1); + + /// compute alpha + const mag_type alpha = (*chi1 > 0 ? one : minus_one)*norm_x; + + /// overwrite x2 with u2 + const value_type chi1_minus_alpha = *chi1 - *alpha; + const value_type inv_chi1_minus_alpha = one/chi1_minus_alpha; + for (int i=0;i::abs(chi1_minus_alpha); + const mag_type norm_x2_div_abs_chi1_minus_alpha = norm_x2 / abs_chi1_minus_alpha; + *tau = one_half + one_half*(norm_x_2_div_abs_chi_1_minus_alpha* + norm_x_2_div_abs_chi_1_minus_alpha); + + /// overwrite chi1 with alpha + *chi1 = alpha; + + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif From 0f5bdfb37d422c8171fe9c077e9a1aadb9469719 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 22 Oct 2018 14:06:45 -0600 Subject: [PATCH 052/190] KokkosBatched - householder implementation and apply method --- .../KokkosBatched_ApplyHouseholder_Decl.hpp | 32 +++++++ ...osBatched_ApplyHouseholder_Serial_Impl.hpp | 64 +++++++++++++ ...ched_ApplyHouseholder_Serial_Internal.hpp} | 91 ++++++------------- .../KokkosBatched_Householder_Decl.hpp | 28 ++++++ .../KokkosBatched_Householder_Serial_Impl.hpp | 37 ++++++++ ...osBatched_Householder_Serial_Internal.hpp} | 29 +++--- 6 files changed, 203 insertions(+), 78 deletions(-) create mode 100644 src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp create mode 100644 src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp rename src/batched/{KokkosBatched_ApplyHouseholder_Internal.hpp => KokkosBatched_ApplyHouseholder_Serial_Internal.hpp} (50%) create mode 100644 src/batched/KokkosBatched_Householder_Decl.hpp create mode 100644 src/batched/KokkosBatched_Householder_Serial_Impl.hpp rename src/batched/{KokkosBatched_Householder_Internal.hpp => KokkosBatched_Householder_Serial_Internal.hpp} (68%) diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp new file mode 100644 index 0000000000..13421f82b0 --- /dev/null +++ b/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp @@ -0,0 +1,32 @@ +#ifndef __KOKKOSBATCHED_APPLY_HOUSEHOLDER_DECL_HPP__ +#define __KOKKOSBATCHED_APPLY_HOUSEHOLDER_DECL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Householder + /// + + // level 1 operation (no blocking algorithm info avail) + template + struct SerialApplyHouseholder { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType + const wViewType &w); + }; + + } +} + +#endif diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp new file mode 100644 index 0000000000..c04fbc510d --- /dev/null +++ b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp @@ -0,0 +1,64 @@ +#ifndef __KOKKOSBATCHED_APPLY_HOUSEHOLDER_SERIAL_IMPL_HPP__ +#define __KOKKOSBATCHED_APPLY_HOUSEHOLDER_SERIAL_IMPL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Householder_Serial_Internal.hpp" + + +namespace KokkosBatched { + namespace Experimental { + + /// + /// Serial Impl + /// =========== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialApplyHouseholder:: + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType &A, + const wViewType &w) { + return SerialApplyLeftHouseholderInternal:: + invoke(A.extent(0)-1, A.extent(1), + tau.data(), + u2.data(), u2.stride(0), + A.data(), A.stride(1), + A.data()+A.stride(0), A.stride(0), A.stride(1), + w.data()); + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialApplyHouseholder:: + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType &A, + const wViewType &w) { + return SerialApplyRightHouseholderInternal:: + invoke(A.extent(0), A.extent(1)-1, + tau.data(), + u2.data(), u2.stride(0), + A.data(), A.stride(0), + A.data()+A.stride(1), A.stride(0), A.stride(1), + w.data()); + } + + } +} + + +#endif diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp similarity index 50% rename from src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp rename to src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp index 069bdd768a..13ef1ad314 100644 --- a/src/batched/KokkosBatched_ApplyHouseholder_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp @@ -1,5 +1,5 @@ -#ifndef __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ -#define __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ +#ifndef __KOKKOSBATCHED_APPLY_HOUSEHOLDER_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_APPLY_HOUSEHOLDER_SERIAL_INTERNAL_HPP__ /// \author Kyungjoo Kim (kyukim@sandia.gov) @@ -21,53 +21,36 @@ namespace KokkosBatched { static int invoke(const int m, // m = NumRows(A2) = numRows(u2) const int n, // n = NumCols(a1t) - const ValueType tau, + const ValueType * tau, /* */ ValueType * u2, const int u2s, /* */ ValueType * a1t, const int a1ts, /* */ ValueType * A2, const int as0, const int as1, /* */ ValueType * w1t) { + typedef ValueType value_type; + // apply a single householder transform H from the left to a row vector a1t // and a matrix A2 - typedef ValueType value_type; - typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; - + const value_type inv_tau = value_type(1)/(*tau); + // compute the followings: // a1t -= inv(tau)(a1t + u2'A2) // A2 -= u2 inv(tau)(a1t + u2'A2) - // w1t = a1t - for (int i=0;i::conj(u2[j*u2s]); - w1t[i] += tmp; - } - // gemv is not implemented for conjugate transpose; if use this, no support for complex - // SerialGemvInternal:: - // invoke(n, m, - // 1, - // A2, as1, as0, - // u2, u2s, - // 1, - // w1t, 1); - + // w1t = a1t + u2'A2 = A2^T conj(u2) // w1t /= tau - const value_type inv_tau = one/tau; - for (int i=0;i::conj(u2[i*u2s])*A2[i*as0+j*as1]; + w1t[j] = tmp*inv_tau; // /= (*tau); + } - // a1t -= w1t (axpy) - for (int i=0;i::mag_type mag_type; + const value_type inv_tau = value_type(1)/(*tau); // compute the followings: // a1 -= inv(tau)(a1 + A2 u2) // A2 -= inv(tau)(a1 + A2 u2) u2' - // w1 = a1 - for (int i=0;i:: - // invoke(m, n, - // 1, - // A2, as0, as1, - // u2, u2s, - // 1, - // w1, 1); - - // w1t /= tau - const value_type inv_tau = one/tau; - for (int i=0;i + struct SerialHouseholder { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const aViewType &a, + const tauViewType &tau); + }; + + } +} + +#endif diff --git a/src/batched/KokkosBatched_Householder_Serial_Impl.hpp b/src/batched/KokkosBatched_Householder_Serial_Impl.hpp new file mode 100644 index 0000000000..ebc5da5393 --- /dev/null +++ b/src/batched/KokkosBatched_Householder_Serial_Impl.hpp @@ -0,0 +1,37 @@ +#ifndef __KOKKOSBATCHED_HOUSEHOLDER_SERIAL_IMPL_HPP__ +#define __KOKKOSBATCHED_HOUSEHOLDER_SERIAL_IMPL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Householder_Serial_Internal.hpp" + + +namespace KokkosBatched { + namespace Experimental { + + /// + /// Serial Impl + /// =========== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialHouseholder:: + invoke(const aViewType &a, + const tauViewType &tau) { + return SerialLeftHouseholderInternal:: + invoke(a.extent(0)-1, + a.data(), + a.data()+a.stride(0), a.stride(0), + tau.data()); + } + + } +} + + +#endif diff --git a/src/batched/KokkosBatched_Householder_Internal.hpp b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp similarity index 68% rename from src/batched/KokkosBatched_Householder_Internal.hpp rename to src/batched/KokkosBatched_Householder_Serial_Internal.hpp index e248588185..f2a191cda8 100644 --- a/src/batched/KokkosBatched_Householder_Internal.hpp +++ b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp @@ -1,5 +1,5 @@ -#ifndef __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ -#define __KOKKOSBATCHED_HOUSEHOLDER_INTERNAL_HPP__ +#ifndef __KOKKOSBATCHED_HOUSEHOLDER_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HOUSEHOLDER_SERIAL_INTERNAL_HPP__ /// \author Kyungjoo Kim (kyukim@sandia.gov) @@ -28,22 +28,22 @@ namespace KokkosBatched { const mag_type zero(0); const mag_type two(2); - const mag_type one_half(1.5); + const mag_type half(0.5); const mag_type one(1); const mag_type minus_one(-1); /// compute the 2norm of x2 - mag_type norm_x2(0); + mag_type norm_x2_square(0); for (int i=0;i::sqrt(norm_x2); + //norm_x2 = Kokkos::Details::ArithTraits::sqrt(norm_x2); /// if norm_x2 is zero, return with trivial values - if (norm_x2 == zero) { + if (norm_x2_square == zero) { *chi1 = -(*chi1); - *tau = one_half; + *tau = half; return 0; } @@ -52,24 +52,23 @@ namespace KokkosBatched { const mag_type norm_chi1 = Kokkos::Details::ArithTraits::abs(*chi1); /// compute 2 norm of x using norm_chi1 and norm_x2 - const mag_type norm_x = Kokkos::Details::ArithTraits::sqrt(norm_x2*norm_x2 + norm_chi1*norm_chi1); + const mag_type norm_x = Kokkos::Details::ArithTraits::sqrt(norm_x2_square + norm_chi1*norm_chi1); /// compute alpha - const mag_type alpha = (*chi1 > 0 ? one : minus_one)*norm_x; + const mag_type alpha = (*chi1 < 0 ? one : minus_one)*norm_x; /// overwrite x2 with u2 - const value_type chi1_minus_alpha = *chi1 - *alpha; + const value_type chi1_minus_alpha = *chi1 - alpha; const value_type inv_chi1_minus_alpha = one/chi1_minus_alpha; for (int i=0;i::abs(chi1_minus_alpha); - const mag_type norm_x2_div_abs_chi1_minus_alpha = norm_x2 / abs_chi1_minus_alpha; - *tau = one_half + one_half*(norm_x_2_div_abs_chi_1_minus_alpha* - norm_x_2_div_abs_chi_1_minus_alpha); + const mag_type chi1_minus_alpha_square = chi1_minus_alpha*chi1_minus_alpha; + *tau = half + half*(norm_x2_square/chi1_minus_alpha_square); /// overwrite chi1 with alpha *chi1 = alpha; From 90ff57b9f1d2c30357d2ae0e3ae7460aad14eb5d Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 23 Oct 2018 12:49:57 -0600 Subject: [PATCH 053/190] KokkosBatched - QR factorization and apply Q method --- .../KokkosBatched_ApplyQ_Serial_Internal.hpp | 141 ++++++++++++++ ...kosBatched_Householder_Serial_Internal.hpp | 1 - .../KokkosBatched_QR_Serial_Internal.hpp | 80 ++++++++ src/batched/KokkosBatched_Util.hpp | 180 ++++++++++++++++++ 4 files changed, 401 insertions(+), 1 deletion(-) create mode 100644 src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_QR_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp new file mode 100644 index 0000000000..d013eac0b6 --- /dev/null +++ b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp @@ -0,0 +1,141 @@ +#ifndef __KOKKOSBATCHED_APPLY_Q_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_APPLY_Q_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_ApplyHouseholder_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + + + struct SerialApplyQ_LeftNoTransForwardInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(B) = NumRows(Q) = NumCols(Q) = NumRows(A) + const int n, // n = NumCols(B) + const int k, // k = NumRows(t) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * B, const int bs0, const int bs1, + /* */ ValueType * w) { + typedef ValueType value_type; + + /// Given a matrix A that includes a series of householder vectors, + /// it applies a unitary matrix Q to B from left without transpose + /// B = Q B = (H0 H1 H2 H3 ... H(k-1)) B + + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + Partition2x1 B_part2x1(bs0); + Partition3x1 B_part3x1(bs0); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithABR(A, m, k, m-k, 0); + t_part2x1.partWithAB (t, k, 0 ); + B_part2x1.partWithAB (B, m, m-k ); + + for (int m_A0=(k-1);m_A0>=0;--m_A0) { + // part 2x2 into 3x3 + A_part3x3.partWithATL(A_part2x2, 1, 1); + t_part3x1.partWithAT (t_part2x1, 1); + value_type *tau = t_part3x1.A1; + + B_part3x1.partWithAT (B_part2x1, 1); + const int m_A2 = m - m_A0 - 1; + /// ----------------------------------------------------- + // left apply householder to partitioned B1 and B2 + SerialApplyLeftHouseholderInternal::invoke(m_A2, n, + tau, + A_part3x3.A21, as0, + B_part3x1.A1, bs1, + B_part3x1.A2, bs0, bs1, + w); + + /// ----------------------------------------------------- + A_part2x2.mergeToABR(A_part3x3); + t_part2x1.mergeToAB (t_part3x1); + B_part2x1.mergeToAB (B_part3x1); + } + return 0; + } + }; + + struct SerialApplyQ_RightNoTransForwardInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(B) = NumRows(Q) = NumCols(Q) = NumRows(A) + const int n, // n = NumCols(B) + const int k, // k = NumRows(t) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * B, const int bs0, const int bs1, + /* */ ValueType * w) { + typedef ValueType value_type; + + /// Given a matrix A that includes a series of householder vectors, + /// it applies a unitary matrix Q to B from left without transpose + /// B = B Q = B (H0 H1 H2 H3 ... H(k-1)) + + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + Partition2x1 B_part2x1(bs0); + Partition3x1 B_part3x1(bs0); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, m, k, 0, 0); + t_part2x1.partWithAT (t, m, 0 ); + B_part2x1.partWithAT (B, m, 0 ); + + for (int m_A0=0;m_A0::sqrt(norm_x2); /// if norm_x2 is zero, return with trivial values if (norm_x2_square == zero) { diff --git a/src/batched/KokkosBatched_QR_Serial_Internal.hpp b/src/batched/KokkosBatched_QR_Serial_Internal.hpp new file mode 100644 index 0000000000..2420ed2de8 --- /dev/null +++ b/src/batched/KokkosBatched_QR_Serial_Internal.hpp @@ -0,0 +1,80 @@ +#ifndef __KOKKOSBATCHED_QR_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_QR_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Householder_Serial_Internal.hpp" +#include "KokkosBatched_ApplyHouseholder_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialQR_Internal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(A) + const int n, // n = NumCols(A) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * w) { + typedef ValueType value_type; + + /// Given a matrix A, it computes QR decomposition of the matrix + /// - t is to store tau and w is for workspace + + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, m, n, 0, 0); + t_part2x1.partWithAT (t, m, 0); + + for (int m_atl=0;m_atl struct Partition1x2; + template struct Partition1x3; + + template + struct Partition1x2 { + const int as1; + ValueType *AL, *AR; + + KOKKOS_INLINE_FUNCTION + Partition1x2(const int arg_as1) + : as1(arg_as1), AL(NULL), AR(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAL(ValueType *A, const int mAL) { + AL = A; AR = AL+mAL*as1; + } + + // A0 A1 are merged into AL + KOKKOS_INLINE_FUNCTION + void mergeToAL(const Partition1x3 &part) { + AL = part.A0; AR = part.A2; + } + }; + + template + struct Partition1x3 { + const int as1; + ValueType *A0, *A1, *A2; + + KOKKOS_INLINE_FUNCTION + Partition1x3(const int arg_as1) + : as1(arg_as1), A0(NULL), A1(NULL), A2(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAR(const Partition1x2 &part, const int mA1) { + A0 = part.AL; A1 = part.AR; A2 = A1 + mA1*as1; + } + }; + + + template struct Partition2x1; + template struct Partition3x1; + + template + struct Partition2x1 { + const int as0; + ValueType *AT, *AB; + + KOKKOS_INLINE_FUNCTION + Partition2x1(const int arg_as0) + : as0(arg_as0), AT(NULL), AB(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAT(ValueType *A, const int mA, const int mAT) { + AT = A; + AB = AT+mAT*as0; + } + + KOKKOS_INLINE_FUNCTION + void partWithAB(ValueType *A, const int mA, const int mAB) { + partWithAT(A, mA, mA-mAB); + } + + // A0 + // A1 is merged into AT + KOKKOS_INLINE_FUNCTION + void mergeToAT(const Partition3x1 &part) { + AT = part.A0; + AB = part.A2; + } + + KOKKOS_INLINE_FUNCTION + void mergeToAB(const Partition3x1 &part) { + AT = part.A0; + AB = part.A1; + } + }; + + template + struct Partition3x1 { + const int as0; + ValueType *A0, + /* */ *A1, + /* */ *A2; + + KOKKOS_INLINE_FUNCTION + Partition3x1(const int arg_as0) + : as0(arg_as0), + A0(NULL), + A1(NULL), + A2(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAB(const Partition2x1 &part, const int mA1) { + A0 = part.AT; + A1 = part.AB; + A2 = A1 + mA1*as0; + } + + KOKKOS_INLINE_FUNCTION + void partWithAT(const Partition2x1 &part, const int mA1) { + A0 = part.AT; + A1 = part.AB - mA1*as0; + A2 = part.AB; + } + }; + + template struct Partition2x2; + template struct Partition3x3; + + template + struct Partition2x2 { + const int as0, as1; + ValueType *ATL, *ATR, *ABL, *ABR; + + KOKKOS_INLINE_FUNCTION + Partition2x2(const int arg_as0, const int arg_as1) + : as0(arg_as0), as1(arg_as1), ATL(NULL), ATR(NULL), ABL(NULL), ABR(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithATL(ValueType *A, + const int mA, const int nA, + const int mATL, const int nATL) { + ATL = A; ATR = ATL+nATL*as1; + ABL = ATL+mATL*as0; ABR = ABL+nATL*as1; + } + + KOKKOS_INLINE_FUNCTION + void partWithABR(ValueType *A, + const int mA, const int nA, + const int mABR, const int nABR) { + partWithATL(A, mA, nA, mA-mABR, nA-nABR); + } + + // A00 A01 + // A10 A11 is merged into ATL + KOKKOS_INLINE_FUNCTION + void mergeToATL(const Partition3x3 &part) { + ATL = part.A00; ATR = part.A02; + ABL = part.A20; ABR = part.A22; + } + + KOKKOS_INLINE_FUNCTION + void mergeToABR(const Partition3x3 &part) { + ATL = part.A00; ATR = part.A01; + ABL = part.A10; ABR = part.A11; + } + }; + + template + struct Partition3x3 { + const int as0, as1; + ValueType *A00, *A01, *A02, + /* */ *A10, *A11, *A12, + /* */ *A20, *A21, *A22; + + + KOKKOS_INLINE_FUNCTION + Partition3x3(const int arg_as0, const int arg_as1) + : as0(arg_as0), as1(arg_as1), + A00(NULL), A01(NULL), A02(NULL), + A10(NULL), A11(NULL), A12(NULL), + A20(NULL), A21(NULL), A22(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithABR(const Partition2x2 &part, const int mA11, const int nA11) { + A00 = part.ATL; A01 = part.ATR; A02 = part.ATR + nA11*as1; + A10 = part.ABL; A11 = part.ABR; A12 = part.ABR + nA11*as1; + A20 = part.ABL + mA11*as0; A21 = part.ABR + mA11*as0; A22 = part.ABR + mA11*as0 + nA11*as1; + } + + KOKKOS_INLINE_FUNCTION + void partWithATL(const Partition2x2 &part, const int mA11, const int nA11) { + A00 = part.ATL; A01 = part.ATR - nA11*as1; A02 = part.ATR; + A10 = part.ABL - mA11*as0; A11 = part.ABR - mA11*as0 - nA11*as1; A12 = part.ABR - mA11*as0; + A20 = part.ABL; A21 = part.ABR - nA11*as1; A22 = part.ABR; + } + }; + + } } From 83438e6d42539ce6eeaf1949a7c3513719ad5cd7 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 23 Oct 2018 17:16:51 -0600 Subject: [PATCH 054/190] KokkosBatched - apply householder debugging --- ...tched_ApplyHouseholder_Serial_Internal.hpp | 24 ++-- .../KokkosBatched_ApplyQ_Serial_Internal.hpp | 52 +++++---- ...ed_HessenbergReduction_Serial_Internal.hpp | 106 ++++++++++++++++++ src/batched/KokkosBatched_Util.hpp | 4 +- 4 files changed, 154 insertions(+), 32 deletions(-) create mode 100644 src/batched/KokkosBatched_HessenbergReduction_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp index 13ef1ad314..53bb8f8f4d 100644 --- a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp @@ -19,8 +19,8 @@ namespace KokkosBatched { template KOKKOS_INLINE_FUNCTION static int - invoke(const int m, // m = NumRows(A2) = numRows(u2) - const int n, // n = NumCols(a1t) + invoke(const int m, + const int n, const ValueType * tau, /* */ ValueType * u2, const int u2s, /* */ ValueType * a1t, const int a1ts, @@ -28,6 +28,10 @@ namespace KokkosBatched { /* */ ValueType * w1t) { typedef ValueType value_type; + /// u2 m x 1 + /// a1t 1 x n + /// A2 m x n + // apply a single householder transform H from the left to a row vector a1t // and a matrix A2 const value_type inv_tau = value_type(1)/(*tau); @@ -63,14 +67,18 @@ namespace KokkosBatched { template KOKKOS_INLINE_FUNCTION static int - invoke(const int m, // m = NumRows(a1) - const int n, // n = NumRows(u2) = NumCols(A2) + invoke(const int m, + const int n, const ValueType * tau, /* */ ValueType * u2, const int u2s, /* */ ValueType * a1, const int a1s, /* */ ValueType * A2, const int as0, const int as1, /* */ ValueType * w1) { typedef ValueType value_type; + /// u2 n x 1 + /// a1 m x 1 + /// A2 m x n + // apply a single householder transform H from the left to a row vector a1t // and a matrix A2 const value_type inv_tau = value_type(1)/(*tau); @@ -82,21 +90,21 @@ namespace KokkosBatched { // w1 = a1 + A2 u2 // w1 /= tau for (int i=0;i::conj(u2[j*u2s]); - + return 0; } }; diff --git a/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp index d013eac0b6..190fee0c72 100644 --- a/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp @@ -21,9 +21,9 @@ namespace KokkosBatched { template KOKKOS_INLINE_FUNCTION static int - invoke(const int m, // m = NumRows(B) = NumRows(Q) = NumCols(Q) = NumRows(A) - const int n, // n = NumCols(B) - const int k, // k = NumRows(t) + invoke(const int m, + const int n, + const int k, /* */ ValueType * A, const int as0, const int as1, /* */ ValueType * t, const int ts, /* */ ValueType * B, const int bs0, const int bs1, @@ -33,6 +33,10 @@ namespace KokkosBatched { /// Given a matrix A that includes a series of householder vectors, /// it applies a unitary matrix Q to B from left without transpose /// B = Q B = (H0 H1 H2 H3 ... H(k-1)) B + /// where + /// A is m x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x n // partitions used for loop iteration Partition2x2 A_part2x2(as0, as1); @@ -79,9 +83,9 @@ namespace KokkosBatched { template KOKKOS_INLINE_FUNCTION static int - invoke(const int m, // m = NumRows(B) = NumRows(Q) = NumCols(Q) = NumRows(A) - const int n, // n = NumCols(B) - const int k, // k = NumRows(t) + invoke(const int m, + const int n, + const int k, /* */ ValueType * A, const int as0, const int as1, /* */ ValueType * t, const int ts, /* */ ValueType * B, const int bs0, const int bs1, @@ -91,6 +95,10 @@ namespace KokkosBatched { /// Given a matrix A that includes a series of householder vectors, /// it applies a unitary matrix Q to B from left without transpose /// B = B Q = B (H0 H1 H2 H3 ... H(k-1)) + /// where + /// A is n x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x n // partitions used for loop iteration Partition2x2 A_part2x2(as0, as1); @@ -99,34 +107,34 @@ namespace KokkosBatched { Partition2x1 t_part2x1(ts); Partition3x1 t_part3x1(ts); - Partition2x1 B_part2x1(bs0); - Partition3x1 B_part3x1(bs0); + Partition1x2 B_part1x2(bs1); + Partition1x3 B_part1x3(bs1); // initial partition of A where ATL has a zero dimension - A_part2x2.partWithATL(A, m, k, 0, 0); - t_part2x1.partWithAT (t, m, 0 ); - B_part2x1.partWithAT (B, m, 0 ); + A_part2x2.partWithATL(A, n, k, 0, 0); + t_part2x1.partWithAT (t, k, 0 ); + B_part1x2.partWithAL (B, n, 0 ); - for (int m_A0=0;m_A0 + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(A) + const int n, // n = NumCols(A) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * w) { + typedef ValueType value_type; + + /// Given a matrix A, it computes hessenberg decomposition of the matrix + /// - t is to store tau and w is for workspace + + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + // partitions used in loop body + Partition2x1 A21_part2x1(as0); + Partition2x1 A22_part2x1(as0); + Partition1x2 A2_part1x2 (as1); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, m, n, 0, 0); + t_part2x1.partWithAT (t, m, 0 ); + + for (int m_atl=0;m_atl 0) { + // partition A21 into 2x1 + A21_part2x1.partWithAT(A_part3x3.A21, m_A22, 1); + + // perform householder transformation + const int m_A22_b = m_A22 - 1; + SerialLeftHouseholderInternal::invoke(m_A22_b, + A21_part2x1.AT, + A21_part2x1.AB, as0, + tau); + + // partition A22 into 2x1 + A22_part2x1.partWithAT(A_part3x3.A22, m_A22, 1); + + // left apply householder to partitioned A22 + SerialApplyLeftHouseholderInternal::invoke(m_A22_b, n_A22, + tau, + A21_part2x1.AB, as0, + A22_part2x1.AT, as1, + A22_part2x1.AB, as0, as1, + w); + + + // partition A*2 column into 1x2 + A2_part1x2.partWithAL(A_part3x3.A02, n_A22, 1); + + // right apply householder to A*2 colums + const int n_A22_r = n_A22 - 1; + SerialApplyRightHouseholderInternal::invoke(m, n_A22_r, + tau, + A21_part2x1.AB, as0, + A2_part1x2.AL, as0, + A2_part1x2.AR, as0, as1, + w); + } + /// ----------------------------------------------------- + A_part2x2.mergeToATL(A_part3x3); + t_part2x1.mergeToAT (t_part3x1); + } + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_Util.hpp b/src/batched/KokkosBatched_Util.hpp index bf1fc2e5c9..0b31374282 100644 --- a/src/batched/KokkosBatched_Util.hpp +++ b/src/batched/KokkosBatched_Util.hpp @@ -369,8 +369,8 @@ namespace KokkosBatched { : as1(arg_as1), AL(NULL), AR(NULL) {} KOKKOS_INLINE_FUNCTION - void partWithAL(ValueType *A, const int mAL) { - AL = A; AR = AL+mAL*as1; + void partWithAL(ValueType *A, const int nA, const int nAL) { + AL = A; AR = AL+nAL*as1; } // A0 A1 are merged into AL From 91f5184d53703fc234e1243c9f89900489d68290 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 23 Oct 2018 17:46:07 -0600 Subject: [PATCH 055/190] KokkosBatched - form Q interface from QR and Hess --- ...atched_HessenbergFormQ_Serial_Internal.hpp | 54 +++++++++++++++++++ ...KokkosBatched_QR_FormQ_Serial_Internal.hpp | 54 +++++++++++++++++++ .../KokkosBatched_SetIdentity_Internal.hpp | 39 ++++++++++++++ 3 files changed, 147 insertions(+) create mode 100644 src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_SetIdentity_Internal.hpp diff --git a/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp new file mode 100644 index 0000000000..e5d23d9307 --- /dev/null +++ b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp @@ -0,0 +1,54 @@ +#ifndef __KOKKOSBATCHED_HESSENBERG_FORM_Q_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HESSENBERG_FORM_Q_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_SetIdentity_Internal.hpp" +#include "KokkosBatched_ApplyQ_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialQR_FormQInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * Q, const int qs0, const int qs1, + /* */ ValueType * w, + const bool is_Q_zero = false) { + typedef ValueType value_type; + + /// Given a matrix A that includes Hessenberg factorization + /// it forms a unitary matrix Q + /// B = Q = (H0 H1 H2 H3 ... H(k-1)) I + /// where + /// A is m x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x m + // set identity + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + return SerialApplyQ_LeftNoTransForwardInternal + ::invoke(m-1, m-1, k, + A+as0, as0, as1, + t, ts, + Q+qs0+qs1, qs0, qs1, + w); + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp b/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp new file mode 100644 index 0000000000..055c6aa1bb --- /dev/null +++ b/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp @@ -0,0 +1,54 @@ +#ifndef __KOKKOSBATCHED_QR_FORM_Q_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_QR_FORM_Q_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_SetIdentity_Internal.hpp" +#include "KokkosBatched_ApplyQ_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialQR_FormQInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * Q, const int qs0, const int qs1, + /* */ ValueType * w, + const bool is_Q_zero = false) { + typedef ValueType value_type; + + /// Given a matrix A that includes QR factorization + /// it forms a unitary matrix Q + /// B = Q = (H0 H1 H2 H3 ... H(k-1)) I + /// where + /// A is m x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x m + // set identity + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + return SerialApplyQ_LeftNoTransForwardInternal + ::invoke(m, m, k, + A, as0, as1, + t, ts, + Q, qs0, qs1, + w); + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_SetIdentity_Internal.hpp b/src/batched/KokkosBatched_SetIdentity_Internal.hpp new file mode 100644 index 0000000000..a0d7816143 --- /dev/null +++ b/src/batched/KokkosBatched_SetIdentity_Internal.hpp @@ -0,0 +1,39 @@ +#ifndef __KOKKOSBATCHED_SET_IDENTITY_INTERNAL_HPP__ +#define __KOKKOSBATCHED_SET_IDENTITY_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + struct SerialSetIdentityInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + const ValueType one(1), zero(0); + for (int j=0;j Date: Thu, 25 Oct 2018 13:55:57 -0600 Subject: [PATCH 056/190] KokkosBatched - given rotation --- .../KokkosBatched_Givens_Serial_Internal.hpp | 66 +++++++++++++++++++ ...kosBatched_Hessenberg_Serial_Internal.hpp} | 6 +- 2 files changed, 69 insertions(+), 3 deletions(-) create mode 100644 src/batched/KokkosBatched_Givens_Serial_Internal.hpp rename src/batched/{KokkosBatched_HessenbergReduction_Serial_Internal.hpp => KokkosBatched_Hessenberg_Serial_Internal.hpp} (95%) diff --git a/src/batched/KokkosBatched_Givens_Serial_Internal.hpp b/src/batched/KokkosBatched_Givens_Serial_Internal.hpp new file mode 100644 index 0000000000..fa38c52786 --- /dev/null +++ b/src/batched/KokkosBatched_Givens_Serial_Internal.hpp @@ -0,0 +1,66 @@ +#ifndef __KOKKOSBATCHED_GIVENS_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_GIVENS_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ValueType chi1, + const Valuetype chi2, + /* */ ValueType * gamma, + /* */ ValueType * sigma, + /* */ ValueType * chi1_new) { + typedef ValueType value_type; + const value_type zero(0); + + value_type cs, sn, r; + if (chi2 == zero) { + r = chi1; + cs = one; + sn = zero; + } else if (chi1 == zero) { + r = chi2; + cs = zero; + sn = one; + } else { + // here we do not care overflow caused by the division although it is probable.... + r = Kokkos::Details::ArithTraits::sqrt(chi1*chi1 + chi2*chi2); + cs = chi1/r; + sn = chi2/r; + + if (Kokkos::Details::ArithTraits::abs(chi1) > + Kokkos::Details::ArithTraits::abs(chi2) && cs < zero) { + cs = -cs; + sn = -sn; + r = -r; + } + + } + + *gamma = cs; + *sigma = sn; + *chi1_new = r; + + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_HessenbergReduction_Serial_Internal.hpp b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp similarity index 95% rename from src/batched/KokkosBatched_HessenbergReduction_Serial_Internal.hpp rename to src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp index 419302bff2..141aafd041 100644 --- a/src/batched/KokkosBatched_HessenbergReduction_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp @@ -1,5 +1,5 @@ -#ifndef __KOKKOSBATCHED_HESSENBERGREDUCTION_SERIAL_INTERNAL_HPP__ -#define __KOKKOSBATCHED_HESSENBERGREDUCTION_SERIAL_INTERNAL_HPP__ +#ifndef __KOKKOSBATCHED_HESSENBERG_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HESSENBERG_SERIAL_INTERNAL_HPP__ /// \author Kyungjoo Kim (kyukim@sandia.gov) @@ -16,7 +16,7 @@ namespace KokkosBatched { /// /// this impl follows the flame interface of householder transformation /// - struct SerialHessenbergReductionInternal { + struct SerialHessenbergInternal { template KOKKOS_INLINE_FUNCTION static int From 9b772ad7bd444d2223d4f353e32d53c00568d1a0 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 29 Oct 2018 16:41:27 -0600 Subject: [PATCH 057/190] KokkosBatched - eigenvalue solve: simple rayleigh quotient shift --- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 78 +++++++++++++ ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 103 +++++++++++++++++ .../KokkosBatched_Givens_Serial_Internal.hpp | 18 +-- ...HessenbergQR_WithShift_Serial_Internal.hpp | 106 ++++++++++++++++++ ...KokkosBatched_QR_FormQ_Serial_Internal.hpp | 10 +- ...Batched_WilkinsonShift_Serial_Internal.hpp | 61 ++++++++++ 6 files changed, 367 insertions(+), 9 deletions(-) create mode 100644 src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp new file mode 100644 index 0000000000..72f3caeb89 --- /dev/null +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -0,0 +1,78 @@ +#ifndef __KOKKOSBATCHED_APPLY_GIVENS_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_APPLY_GIVENS_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialApplyLeftGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair G, + const int n, + /* */ ValueType * a1t, const int a1ts, + /* */ ValueType * a2t, const int a2ts) { + typedef ValueType value_type; + + /// G = [ gamma -sigma; + /// sigma gamma ]; + /// A := G A + /// where gamma is G.first and sigma is G.second + + const value_type gamma = G.first; + const value_type sigma = G.second; + + for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair G, + const int m, + /* */ ValueType * a1, const int a1s, + /* */ ValueType * a2, const int a2s) { + typedef ValueType value_type; + + /// G = [ gamma -sigma; + /// sigma gamma ]; + /// A := A G' + /// where gamma is G.first and sigma is G.second + + const value_type gamma = G.first; + const value_type sigma = G.second; + + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * H, const int hs0, const int hs1, + const int max_iteration = 1000) { + typedef ValueType value_type; + typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + + const value_type zero(0); + const mag_type tol = 1000*Kokkos::Details::ArithTraits::epsilon(); + + /// Given a strict Hessenberg matrix H (m x m), + /// it computes all eigenvalues via Hessenberg QR algorithm with a shift + switch (m) { + case 0: + case 1: { + // do nothing + break; + } + case 2: { + // do later + break; + } + default: { + // when m > 2; first test use implicit hessenberg qr step + for (int m_H=m;m_H>1;--m_H) { + const int last_idx = m_H-1; + value_type *last_diag = H + last_idx*(hs0+hs1); + value_type *left_from_last_diag = last_diag - hs1; + value_type *last_2x2 = left_from_last_diag - hs0; + int iter = 0; + bool converge = Kokkos::Details::ArithTraits::abs(*left_from_last_diag) < tol; + printf(" m_H = %d tol = %e\n", m_H, tol); + while (!converge && iter < max_iteration) { + value_type shift; + { + /// 0. No shift (for testing only) + shift = zero; + + /// 1. Rayleigh quotient shift (all eigenvalues are real; used for testing) + // shift = *last_diag; + + /// 2. Wilkinson shift (francis algorithm) + // value_type lambda1, lambda2; + // bool is_complex; + // SerialWilkinsonShiftInternal::invoke(last_2x2[0*hs0+0*hs1], last_2x2[0*hs0+1*hs1], + // last_2x2[1*hs0+0*hs1], last_2x2[1*hs0+1*hs1], + // &lambda1, &lambda2, + // &is_complex); + + // const auto target = last_2x2[1*hs0+1*hs1]; + // shift = ( Kokkos::Details::ArithTraits::abs(target - lambda1) > + // Kokkos::Details::ArithTraits::abs(target - lambda2) ? lambda2 : lambda1 ); + } + + /// QR sweep + SerialHessenbergQR_WithShiftInternal::invoke(m_H, + H, hs0, hs1, + shift); + + converge = Kokkos::Details::ArithTraits::abs(*left_from_last_diag) < tol; + ++iter; + } + printf("H in eigenvalues converges in %d = \n", iter); + for (int i=0;i * G, /* */ ValueType * chi1_new) { typedef ValueType value_type; - const value_type zero(0); - + const value_type zero(0), one(1); + /// compute G = [ gamma -sigma; + /// sigma gamma ]; + /// G.first = gamma and G.second = sigma + /// this rotation satisfy the following + /// G' [chi1; = [ alpha; + /// chi2] zero ]; value_type cs, sn, r; if (chi2 == zero) { r = chi1; @@ -51,8 +55,8 @@ namespace KokkosBatched { } - *gamma = cs; - *sigma = sn; + G->first = cs; + G->second = sn; *chi1_new = r; return 0; diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp new file mode 100644 index 0000000000..33957c7bdf --- /dev/null +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -0,0 +1,106 @@ +#ifndef __KOKKOSBATCHED_HESSENBERG_QR_WITH_SHIFT_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_HESSENBERG_QR_WITH_SHIFT_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Givens_Serial_Internal.hpp" +#include "KokkosBatched_ApplyGivens_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialHessenbergQR_WithShiftInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * H, const int hs0, const int hs1, + const ValueType shift) { + typedef ValueType value_type; + const value_type zero(0); + + /// Given a strict Hessenberg matrix H (m x m), + /// it computes a single implicit QR step with a given shift + /// - it assumes H has zeros on subdiagonal entries ( + /// givens rotation is defined as G = [gamma -sigma + /// sigma gamma] + /// G' [chi1 chi2]^t = [alpha 0]^T + /// where G is stored as a pair of gamma and sigma + Kokkos::pair G; + + /// 0. compute the first givens rotation that introduces a bulge + { + const value_type chi1 = H[0] - shift; + const value_type chi2 = H[hs0]; + /* */ value_type alpha; + SerialGivensInternal::invoke(chi1, chi2, + &G, + &alpha); + + value_type *h11 = H; + value_type *h21 = H + hs0; + value_type *h12 = H + hs1; + + // apply G' from left + G.second = -G.second; // transpose G + const int nn = m; + SerialApplyLeftGivensInternal::invoke (G, nn, + h11, hs1, + h21, hs1); + + // apply (G')' from right + const int mm = m < 3 ? m : 3; + SerialApplyRightGivensInternal::invoke(G, mm, + h11, hs0, + h12, hs0); + } + + /// 1. chase the bulge + + // partitions used for loop iteration + Partition2x2 H_part2x2(hs0, hs1); + Partition3x3 H_part3x3(hs0, hs1); + + // initial partition of A where ATL has a zero dimension + H_part2x2.partWithATL(H, m, m, 1, 1); + + for (int m_htl=1;m_htl<(m-1);++m_htl) { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + const int n_hbr = m - m_htl; + /// ----------------------------------------------------- + const value_type chi1 = *H_part3x3.A10; + const value_type chi2 = *H_part3x3.A20; + SerialGivensInternal::invoke(chi1, chi2, + &G, + H_part3x3.A10); + *H_part3x3.A20 = zero; // explicitly set zero + G.second = -G.second; // transpose G + + const int nn = m - m_htl; + SerialApplyLeftGivensInternal::invoke (G, nn, + H_part3x3.A11, hs1, + H_part3x3.A21, hs1); + const int mtmp = m_htl+3, mm = mtmp < m ? mtmp : m; + SerialApplyRightGivensInternal::invoke(G, mm, + H_part3x3.A01, hs0, + H_part3x3.A02, hs0); + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); + } + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp b/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp index 055c6aa1bb..9241caad99 100644 --- a/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_QR_FormQ_Serial_Internal.hpp @@ -5,6 +5,7 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) #include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Set_Internal.hpp" #include "KokkosBatched_SetIdentity_Internal.hpp" #include "KokkosBatched_ApplyQ_Serial_Internal.hpp" @@ -16,7 +17,7 @@ namespace KokkosBatched { /// /// this impl follows the flame interface of householder transformation /// - struct SerialQR_FormQInternal { + struct SerialQR_FormQ_Internal { template KOKKOS_INLINE_FUNCTION static int @@ -36,8 +37,13 @@ namespace KokkosBatched { /// A is m x k (holding H0, H1 ... H(k-1) /// t is k x 1 /// B is m x m + // set identity - SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + if (is_Q_zero) + SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); + else + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + return SerialApplyQ_LeftNoTransForwardInternal ::invoke(m, m, k, A, as0, as1, diff --git a/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp new file mode 100644 index 0000000000..afdc7d8aec --- /dev/null +++ b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp @@ -0,0 +1,61 @@ +#ifndef __KOKKOSBATCHED_WILKINSON_SHIFT_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_WILKINSON_SHIFT_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialWilkinsonShiftInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ValueType a, const ValueType b, + const ValueType c, const ValueType d, + /* */ ValueType * lambda1, + /* */ ValueType * lambda2, + /* */ bool * is_complex) { + /// compute eigenvalues of 2x2 system [a b; + /// c d] + /// when the system has a real complex values, + /// lambda1 and lambda2 are real eigenvalues + /// if the system has a complex eigenvalue pair, + /// then lambda1 and lambda2 are redefined as follows + /// lambda1 := lambda1 + lambda2 + /// lambda2 := lambda1 * lambda2 + typedef ValueType value_type; + const value_type half(0.5), two(2); + const value_type p = (a+d)*half; + const value_type q = (b*c-a*d); + const value_type v = p*p+q; + if (v < 0) { + // complex + const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(-v); + *lambda1 = two*p; + *lambda2 = two*p*p+q; + *is_complex = true; + } else { + // real + const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(v); + *lambda1 = p+sqrt_v; + *lambda2 = p-sqrt_v; + *is_complex = false; + } + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif From aa399d2f16b4c5a5005be48b75387bcad18cfdee Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 30 Oct 2018 12:09:46 -0600 Subject: [PATCH 058/190] KokkosBatched - implicit q eigenvalue is working --- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 82 +++++++++++-------- ...HessenbergQR_WithShift_Serial_Internal.hpp | 10 +-- 2 files changed, 53 insertions(+), 39 deletions(-) diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index 52a6d218e4..50c037b32b 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -37,59 +37,73 @@ namespace KokkosBatched { // do nothing break; } - case 2: { - // do later - break; - } default: { // when m > 2; first test use implicit hessenberg qr step - for (int m_H=m;m_H>1;--m_H) { - const int last_idx = m_H-1; - value_type *last_diag = H + last_idx*(hs0+hs1); - value_type *left_from_last_diag = last_diag - hs1; - value_type *last_2x2 = left_from_last_diag - hs0; - int iter = 0; - bool converge = Kokkos::Details::ArithTraits::abs(*left_from_last_diag) < tol; - printf(" m_H = %d tol = %e\n", m_H, tol); - while (!converge && iter < max_iteration) { + const int hs = hs0+hs1; + int iter(0); + bool converge = false; + while (!converge && iter < max_iteration) { + /// 0. find a subsystem to compute eigenvalues + int cnt = 1; + + // - find mbeg (first nonzero subdiag value) + for (;cnt::abs(val) > tol) break; + } + const int mbeg = cnt-1; + + // - find mend (first zero subdiag value) + for (;cnt::abs(val) < tol) break; + } + const int mend = cnt; + + // if there exist non-converged eigen values + //printf("iter %d mbeg %d mend %d\n", iter, mbeg, mend); + if (mbeg < mend && mbeg < (m-1)) { + /// 1. find shift value_type shift; { - /// 0. No shift (for testing only) - shift = zero; + /// case 0. No shift (testing only) + //shift = zero; - /// 1. Rayleigh quotient shift (all eigenvalues are real; used for testing) - // shift = *last_diag; + /// case 1. Rayleigh quotient shift (all eigenvalues are real; testing only) + shift = *(H+(mend-1)*hs); - /// 2. Wilkinson shift (francis algorithm) + /// case 2. Wilkinson shift (francis algorithm) // value_type lambda1, lambda2; // bool is_complex; // SerialWilkinsonShiftInternal::invoke(last_2x2[0*hs0+0*hs1], last_2x2[0*hs0+1*hs1], // last_2x2[1*hs0+0*hs1], last_2x2[1*hs0+1*hs1], // &lambda1, &lambda2, // &is_complex); - + // const auto target = last_2x2[1*hs0+1*hs1]; // shift = ( Kokkos::Details::ArithTraits::abs(target - lambda1) > // Kokkos::Details::ArithTraits::abs(target - lambda2) ? lambda2 : lambda1 ); } - - /// QR sweep - SerialHessenbergQR_WithShiftInternal::invoke(m_H, - H, hs0, hs1, + + /// 2. QR sweep + SerialHessenbergQR_WithShiftInternal::invoke(mend-mbeg, + H+hs*mbeg, hs0, hs1, shift); - - converge = Kokkos::Details::ArithTraits::abs(*left_from_last_diag) < tol; - ++iter; + } else { + /// 3. all eigenvalues are converged + converge = true; } - printf("H in eigenvalues converges in %d = \n", iter); - for (int i=0;i Date: Wed, 31 Oct 2018 15:53:17 -0600 Subject: [PATCH 059/190] D2 Coloring: Disable Team Policy Functors The D2 Coloring functors using team and vector policy are broken. They're parked on a branch on my fork for safe keeping, but to keep the PR's cleaner for KokkosKernels I'm cleaning these up. In this commit, they're just checked out, the next commit I will remove them from this branch. --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 24 +++++---- src/graph/KokkosGraph_Distance2Color.hpp | 2 + src/graph/KokkosGraph_GraphColorHandle.hpp | 4 ++ .../impl/KokkosGraph_Distance2Color_impl.hpp | 49 ++++++++++++------- 4 files changed, 51 insertions(+), 28 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 34747d6252..4522f8574e 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -116,7 +116,9 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array." << std::endl +#if 0 << spaces << " COLORING_D2_VBTP - VB with Team Policy (type 1)" << std::endl +#endif << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl @@ -198,6 +200,7 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 2; got_required_param_algorithm = true; } +#if 0 else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP")) { params.algorithm = 3; @@ -223,6 +226,12 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 7; got_required_param_algorithm = true; } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP_BIT")) + { + params.algorithm = 11; + got_required_param_algorithm = true; + } +#endif else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) { params.algorithm = 8; @@ -238,11 +247,6 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 10; got_required_param_algorithm = true; } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP_BIT")) - { - params.algorithm = 11; - got_required_param_algorithm = true; - } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; @@ -364,6 +368,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VB); label_algorithm = "COLORING_D2_VB"; break; +#if 0 case 3: kh.create_graph_coloring_handle(COLORING_D2_VBTP); label_algorithm = "COLORING_D2_VBTP"; @@ -384,6 +389,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VBTPVR2); label_algorithm = "COLORING_D2_VBTPVR2"; break; + case 11: + kh.create_graph_coloring_handle(COLORING_D2_VBTP_BIT); + label_algorithm = "COLORING_D2_VBTP_BIT"; + break; +#endif case 8: kh.create_graph_coloring_handle(COLORING_D2_SERIAL); label_algorithm = "COLORING_D2_SERIAL"; @@ -396,10 +406,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VB_BIT_EF); label_algorithm = "COLORING_D2_VB_BIT_EF"; break; - case 11: - kh.create_graph_coloring_handle(COLORING_D2_VBTP_BIT); - label_algorithm = "COLORING_D2_VBTP_BIT"; - break; default: kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 0bdb1adaa5..3457740eb3 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -115,12 +115,14 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: +#if 0 case COLORING_D2_VBTP: case COLORING_D2_VBTP_BIT: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: case COLORING_D2_VBTPVR1: case COLORING_D2_VBTPVR2: +#endif { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 5c8c916b29..197bb03656 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -69,12 +69,14 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT COLORING_D2_VB_BIT_EF, // Distance-2 Graph Coloring Vertex Based BIT + Edge Filtering +#if 0 COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy COLORING_D2_VBTP_BIT, // Distance-2 Graph Coloring Vertex Based BIT w/ Team Policy COLORING_D2_VBTP2, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 2) COLORING_D2_VBTP3, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) COLORING_D2_VBTPVR1, // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 1) COLORING_D2_VBTPVR2 // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 2) +#endif }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -649,12 +651,14 @@ class GraphColoringHandle case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: +#if 0 case COLORING_D2_VBTP: case COLORING_D2_VBTP_BIT: case COLORING_D2_VBTP2: case COLORING_D2_VBTP3: case COLORING_D2_VBTPVR1: case COLORING_D2_VBTPVR2: +#endif this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 5cac6440da..aad751fed7 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -477,6 +477,8 @@ class GraphColorD2 } + + /** * Print out the histogram of colors in a more human friendly format * This will not print out all the colors if there are many. @@ -507,7 +509,7 @@ class GraphColorD2 { // Vertex group chunking nnz_lno_t v_chunk_size = this->_chunkSize; - nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; // TODO: This probably needs fixing + nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; std::cout << ">>> this->nv = " << this->nv << std::endl; std::cout << ">>> v_chunk_size = " << v_chunk_size << std::endl; @@ -559,6 +561,7 @@ class GraphColorD2 } + /** * Compute the maximum distance-1 degree. */ @@ -615,7 +618,9 @@ class GraphColorD2 chunkSize_ = 1; } +#if 0 const size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; +#endif // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) @@ -632,7 +637,7 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; - +#if 0 // Two level parallelism: // 1. [P] loop over chunks of vertices // 2. [P] loop over vertices in chunks @@ -651,7 +656,8 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; - +#endif +#if 0 // Two level parallelism: // 1. [P] loop over chunks of vertices // 2. [S] loop over vertices in chunks @@ -670,7 +676,8 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; - +#endif +#if 0 // Two level parallelism: // 1. [P] loop over chunks of vertices // 2. [S] loop over vertices in chunks @@ -689,7 +696,8 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; - +#endif +#if 0 // Three level parallelism: // 1. [P] loop over chunks of vertices // 2. [P] loop over vertices in chunks @@ -708,7 +716,8 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; - +#endif +#if 0 // Three level parallelism: // 1. [P] loop over chunks of vertices // 2. [P] loop over vertices in chunks @@ -728,7 +737,7 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; - +#endif // One level Perallelism, BIT Array for coloring // 1. [P] loop over vertices // 2. [S] loop over color offset blocks @@ -741,6 +750,7 @@ class GraphColorD2 } break; +#if 0 // Two level Perallelism, BIT Array for coloring // 1. [P] loop over chunks of vertices // 2. [P] loop over vertices in chunks @@ -760,6 +770,7 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); } break; +#endif default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type or invalid for non Edge Filtering mode."); @@ -1246,7 +1257,7 @@ class GraphColorD2 }; // struct functorGreedyColorVB_BIT (end) - +#if 0 /** * Functor for VBTP_BIT algorithm coloring without edge filtering. * Two level parallelism @@ -1387,7 +1398,7 @@ class GraphColorD2 }); // parallel_for ichunk... } // operator() (end) }; // struct functorGreedyColorVBTP_BIT (end) - +#endif /** @@ -1547,7 +1558,7 @@ class GraphColorD2 }; // struct functorGreedyColorVB_BIT_EF (end) - +#if 0 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop over chunks @@ -1662,9 +1673,9 @@ class GraphColorD2 }); // for ichunk ... } // operator() (end) }; // struct functorGreedyColorVBTP (end) +#endif - - +#if 0 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop over neighbors @@ -1789,9 +1800,9 @@ class GraphColorD2 } // for ichunk... } // operator() (end) }; // struct functorGreedyColorVBTP2 (end) +#endif - - +#if 0 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled @@ -1913,9 +1924,9 @@ class GraphColorD2 } // for ichunk... } // operator() (end) }; // struct functorGreedyColorVBTP3 (end) +#endif - - +#if 0 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop over chunks @@ -2039,9 +2050,9 @@ class GraphColorD2 }); // for ichunk... } // operator() (end) }; // struct functorGreedyColorVBTPVR1 (end) +#endif - - +#if 0 /** * Functor for VB algorithm speculative coloring without edge filtering. * Team Policy Enabled on loop-over -chunks @@ -2164,7 +2175,7 @@ class GraphColorD2 }); // for ichunk... } // operator() (end) }; // struct functorGreedyColorVBTPVR2 (end) - +#endif template From edcd96e87c2055f1e1751d4eb57b57175f4b50b0 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 31 Oct 2018 16:06:23 -0600 Subject: [PATCH 060/190] D2 Coloring: Cleaning up unused team policy code Second commit, removing the team-policy code that was commented out. The TP functors are parked in the [Distance2GraphColor-Archive][1] branch on my fork. [1]: https://github.com/william76/kokkos-kernels/tree/Distance2GraphColor-Archive --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 61 -- src/graph/KokkosGraph_Distance2Color.hpp | 8 - src/graph/KokkosGraph_GraphColorHandle.hpp | 16 - .../impl/KokkosGraph_Distance2Color_impl.hpp | 888 ------------------ 4 files changed, 973 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 4522f8574e..1e645d9f71 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -116,9 +116,6 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array." << std::endl -#if 0 - << spaces << " COLORING_D2_VBTP - VB with Team Policy (type 1)" << std::endl -#endif << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl @@ -200,38 +197,6 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 2; got_required_param_algorithm = true; } -#if 0 - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP")) - { - params.algorithm = 3; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP2")) - { - params.algorithm = 4; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP3")) - { - params.algorithm = 5; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTPVR1")) - { - params.algorithm = 6; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTPVR2")) - { - params.algorithm = 7; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VBTP_BIT")) - { - params.algorithm = 11; - got_required_param_algorithm = true; - } -#endif else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) { params.algorithm = 8; @@ -368,32 +333,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_graph_coloring_handle(COLORING_D2_VB); label_algorithm = "COLORING_D2_VB"; break; -#if 0 - case 3: - kh.create_graph_coloring_handle(COLORING_D2_VBTP); - label_algorithm = "COLORING_D2_VBTP"; - break; - case 4: - kh.create_graph_coloring_handle(COLORING_D2_VBTP2); - label_algorithm = "COLORING_D2_VBTP2"; - break; - case 5: - kh.create_graph_coloring_handle(COLORING_D2_VBTP3); - label_algorithm = "COLORING_D2_VBTP3"; - break; - case 6: - kh.create_graph_coloring_handle(COLORING_D2_VBTPVR1); - label_algorithm = "COLORING_D2_VBTPVR1"; - break; - case 7: - kh.create_graph_coloring_handle(COLORING_D2_VBTPVR2); - label_algorithm = "COLORING_D2_VBTPVR2"; - break; - case 11: - kh.create_graph_coloring_handle(COLORING_D2_VBTP_BIT); - label_algorithm = "COLORING_D2_VBTP_BIT"; - break; -#endif case 8: kh.create_graph_coloring_handle(COLORING_D2_SERIAL); label_algorithm = "COLORING_D2_SERIAL"; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 3457740eb3..c664b237ea 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -115,14 +115,6 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: -#if 0 - case COLORING_D2_VBTP: - case COLORING_D2_VBTP_BIT: - case COLORING_D2_VBTP2: - case COLORING_D2_VBTP3: - case COLORING_D2_VBTPVR1: - case COLORING_D2_VBTPVR2: -#endif { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 197bb03656..2a0be0b8f8 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -69,14 +69,6 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT COLORING_D2_VB_BIT_EF, // Distance-2 Graph Coloring Vertex Based BIT + Edge Filtering -#if 0 - COLORING_D2_VBTP, // Distance-2 Graph Coloring Vertex Based w/ Team Policy - COLORING_D2_VBTP_BIT, // Distance-2 Graph Coloring Vertex Based BIT w/ Team Policy - COLORING_D2_VBTP2, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 2) - COLORING_D2_VBTP3, // Distance-2 Graph Coloring Vertex Based w/ Team Policy (WCMCLEN: Experimental variant 3) - COLORING_D2_VBTPVR1, // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 1) - COLORING_D2_VBTPVR2 // Distance-2 Graph Coloring Vertex Based w/ TP @ Chunks + VectorRange (WCMCLEN: Experimental variant 2) -#endif }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -651,14 +643,6 @@ class GraphColoringHandle case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: -#if 0 - case COLORING_D2_VBTP: - case COLORING_D2_VBTP_BIT: - case COLORING_D2_VBTP2: - case COLORING_D2_VBTP3: - case COLORING_D2_VBTPVR1: - case COLORING_D2_VBTPVR2: -#endif this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index aad751fed7..3f1f44a54a 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -618,10 +618,6 @@ class GraphColorD2 chunkSize_ = 1; } -#if 0 - const size_t num_chunks = current_vertexListLength_ / chunkSize_ + 1; -#endif - // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) { @@ -637,107 +633,7 @@ class GraphColorD2 Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; -#if 0 - // Two level parallelism: - // 1. [P] loop over chunks of vertices - // 2. [P] loop over vertices in chunks - // 3. [S] loop over vertex neighbors - // 4. [S] loop over vertex neighbors of neighbors - case COLORING_D2_VBTP: - { - functorGreedyColorVBTP gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, chunkSize_); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #endif - - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif -#if 0 - // Two level parallelism: - // 1. [P] loop over chunks of vertices - // 2. [S] loop over vertices in chunks - // 3. [P] loop over vertex neighbors - // 4. [S] loop over vertex neighbors of neighbors - case COLORING_D2_VBTP2: - { - functorGreedyColorVBTP2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #endif - - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif -#if 0 - // Two level parallelism: - // 1. [P] loop over chunks of vertices - // 2. [S] loop over vertices in chunks - // 3. [S] loop over vertex neighbors - // 4. [P] loop over vertex neighbors of neighbors - case COLORING_D2_VBTP3: - { - functorGreedyColorVBTP3 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #endif - - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif -#if 0 - // Three level parallelism: - // 1. [P] loop over chunks of vertices - // 2. [P] loop over vertices in chunks - // 3. [P] loop over vertex neighbors - // 4. [S] loop over vertex neighbors of neighbors - case COLORING_D2_VBTPVR1: - { - functorGreedyColorVBTPVR1 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, chunkSize_, 32); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); - #endif - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif -#if 0 - // Three level parallelism: - // 1. [P] loop over chunks of vertices - // 2. [P] loop over vertices in chunks - // 3. [S] loop over color offset blocks - // 4. [S] loop over vertex neighbors - // 5. [P] loop over vertex neighbors of neighbors - case COLORING_D2_VBTPVR2: - { - functorGreedyColorVBTPVR2 gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, chunkSize_, 32); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO, 1); - #endif - - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif // One level Perallelism, BIT Array for coloring // 1. [P] loop over vertices // 2. [S] loop over color offset blocks @@ -750,28 +646,6 @@ class GraphColorD2 } break; -#if 0 - // Two level Perallelism, BIT Array for coloring - // 1. [P] loop over chunks of vertices - // 2. [P] loop over vertices in chunks - // 3. [S] loop over color offset blocks - // 4. [S] loop over vertex neighbors - // 5. [S] loop over vertex neighbors of neighbors - case COLORING_D2_VBTP_BIT: - { - functorGreedyColorVBTP_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_, chunkSize_); - - #if defined(KOKKOS_ENABLE_CUDA) - const team_policy_t policy_inst(num_chunks, chunkSize_); - #else - const team_policy_t policy_inst(num_chunks, Kokkos::AUTO); - #endif - - Kokkos::parallel_for("LoopOverChunks", policy_inst, gc); - } - break; -#endif - default: throw std::invalid_argument("Unknown Distance-2 Algorithm Type or invalid for non Edge Filtering mode."); } @@ -1257,149 +1131,6 @@ class GraphColorD2 }; // struct functorGreedyColorVB_BIT (end) -#if 0 - /** - * Functor for VBTP_BIT algorithm coloring without edge filtering. - * Two level parallelism - * - [P] Loop over chunks - * - [P] Loop over vertices in each chunk - * - [S] Loop over offset range(s) - * - [S] Loop over neighbors of vid: vid_d1 - * - [S] Loop over neighbors of vid_d1: vid_d2 - */ - struct functorGreedyColorVBTP_BIT - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTP_BIT(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) - { - if(chunk_id * _chunkSize + ichunk < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - - // If vertex is not colored yet... - if(_colors(vid) == 0) - { - size_type vid_adj_begin = _idx(vid); - size_type vid_adj_end = _idx(vid + 1); - - bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - // Forbidden colors - // - single long int for forbidden colors - bit_64_forbidden_t forbidden = 0; - - // If all available colors for this range are unavailable we can break out of the nested loops - bool break_out = false; - - // Loop over distance-1 neighbors of vid - for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) - { - const nnz_lno_t vid_d1 = _adj(vid_adj); - size_type vid_d1_adj_begin = _t_idx(vid_d1); - size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - - // Loop over distance-2 neighbors of vid - for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) - { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); - - // Ignore Distance-2 Self Loops - if(vid_d2 != vid && vid_d2 < nv) - { - color_t color = _colors(vid_d2); - color_t color_offset = color - offset; - - // if color is within the current range, or if its color is in a previously traversed - // range - if(color && color_offset <= VBBIT_D2_COLORING_FORBIDDEN_SIZE) - { - // if it is in the current range, then add the color to the banned colors - if(color > offset) - { - // convert color to bit representation - bit_64_forbidden_t ban_color_bit = 1; - - ban_color_bit = ban_color_bit << (color_offset - 1); - - // add it to forbidden colors - forbidden = forbidden | ban_color_bit; - - // if there are no available colors in this range then exit early, - // no need to traverse the rest. - if(0 == ~forbidden) - { - break_out = true; - } - } - } - } // if vid_d2... - } // for vid_d1_adj... - } // for vid_adj... - forbidden = ~(forbidden); - - // check if an available color exists. - if(forbidden) - { - // if there is an available color, choose the first color, using 2s complement. - bit_64_forbidden_t new_color = forbidden & (-forbidden); - color_t val = 1; - - // convert it back to decimal color. - while((new_color & 1) == 0) - { - ++val; - new_color = new_color >> 1; - } - _colors(vid) = val + offset; - foundColor = true; - break; - } - } // for !foundColor - } // if _colors(vid)==0 - } // if vid_ * _chunkSize ... - }); // parallel_for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVBTP_BIT (end) -#endif - /** * Functor for VB_BIT_EF algorithm coloring without edge filtering. @@ -1558,625 +1289,6 @@ class GraphColorD2 }; // struct functorGreedyColorVB_BIT_EF (end) -#if 0 - /** - * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled on loop over chunks - */ - struct functorGreedyColorVBTP - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTP(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) { - if(chunk_id * _chunkSize + ichunk < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - - // Already colored this vertex. - if(_colors(vid) <= 0) - { - bool foundColor = false; // Have we found a valid color? - - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are added in the loops over neighbors, then - // atomics will be necessary for updating this. - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - - // Do multiple passes if we fill the current range of possible colors - // * TODO: Determine if we can cap this at something smaller than nv, or if it matters. - for(color_t offset=0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) - { - // initialize the forbidden array to { false } - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - - // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for - // UNCOLORED vertices so we should start coloring at 1. - if(0 == offset) - { - forbidden[0] = true; - } - - // Loop over neighbors - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - - // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) - { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - forbidden[c - offset] = true; - } - } // if vid_d2 != vid ... - } // for vid_d2_adj ... - } // for vid_d1_adj ... - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c=0 ... - } // for offset=0 ... - } // if _colors(vid) <= 0 ... - } // if chunk_id* ... - }); // for ichunk ... - } // operator() (end) - }; // struct functorGreedyColorVBTP (end) -#endif - -#if 0 - /** - * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled on loop over neighbors - * - Serialized the loop over chunks - */ - struct functorGreedyColorVBTP2 - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTP2(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) - { - const nnz_lno_t vertex_list_idx = chunk_id * _chunkSize + ichunk; - if(vertex_list_idx < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(vertex_list_idx); - - // Already colored this vertex. - if(_colors(vid) <= 0) - { - bool foundColor = false; // Have we found a valid color? - - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are added in the loops over neighbors, then - // atomics will be necessary for updating this. - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - - // Do multiple passes if the array is too small. - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - - while(!foundColor && offset < nv) - { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - - // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for - // UNCOLORED vertices so we should start coloring at 1. - if(0 == offset) - { - forbidden[0] = true; - } - - // Loop over neighbors - // for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) - { - const size_type vid_d1_adj = _idx(vid) + idx; - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - - // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) - { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - Kokkos::atomic_fetch_or(&forbidden[c - offset], true); - } - } - } - }); - - thread.team_barrier(); - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while(!foundColor) - } // if _colors(vid) <= 0 ... - } // if vid_ * ...... - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVBTP2 (end) -#endif - -#if 0 - /** - * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled - * - trying out removing the loop-over-chunks stuff - */ - struct functorGreedyColorVBTP3 - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTP3(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - for(nnz_lno_t ichunk = 0; ichunk < _chunkSize; ichunk++) - { - const nnz_lno_t vertex_list_idx = chunk_id * _chunkSize + ichunk; - if(vertex_list_idx < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(vertex_list_idx); - - // Already colored this vertex. - if(_colors(vid) <= 0) - { - bool foundColor = false; // Have we found a valid color? - - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are added in the loops over neighbors, then - // atomics will be necessary for updating this. - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - - // Do multiple passes if the array is too small. - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - - while(!foundColor && offset < nv) - { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - - // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for - // UNCOLORED vertices so we should start coloring at 1. - if(0 == offset) - { - forbidden[0] = true; - } - - // Loop over neighbors - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - - // Loop over distance-2 neighbors - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) - { - const size_type vid_d2_adj = _t_idx(vid_d1) + idx; - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - Kokkos::atomic_fetch_or(&forbidden[c - offset], true); - } - } - }); - } - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while(!foundColor) - } // if _colors(vid) <= 0 ... - } // if vertex_list_idx < _vertexListLength - } // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVBTP3 (end) -#endif - -#if 0 - /** - * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled on loop over chunks - * Vector Range Enabled on loop over neighbors of neighbors - */ - struct functorGreedyColorVBTPVR1 - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTPVR1(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) - { - if(chunk_id * _chunkSize + ichunk < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - - // Already colored this vertex. - if(_colors(vid) <= 0) - { - bool foundColor = false; // Have we found a valid color? - - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are added in the loops over neighbors, then - // atomics will be necessary for updating this. - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - - // Do multiple passes if the array is too small. - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - - while(!foundColor && offset < nv) - { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - - // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for - // UNCOLORED vertices so we should start coloring at 1. - if(0 == offset) - { - forbidden[0] = true; - } - - // Loop over neighbors - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _idx(vid + 1) - _idx(vid)), [&](const size_type &idx) - { - //size_type vid_d1_adj = idx + _idx(vid); - const size_type vid_d1_adj = _idx(vid) + idx; - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - - // Loop over distance-2 neighbors - for(size_type vid_d2_adj = _t_idx(vid_d1); vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) - { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - Kokkos::atomic_fetch_or(&forbidden[c - offset], true); - } - } - } - }); - - thread.team_barrier(); - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while(!foundColor) - } // if _colors(vid) <= 0 ... - } // if chunk_id*... - }); // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVBTPVR1 (end) -#endif - -#if 0 - /** - * Functor for VB algorithm speculative coloring without edge filtering. - * Team Policy Enabled on loop-over -chunks - * Vector Range Enabled on loop-over-neighbors - */ - struct functorGreedyColorVBTPVR2 - { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVBTPVR2(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), - _vertexListLength(vertexListLength), _chunkSize(chunkSize) - { - } - - - // Color vertex i with smallest available color. - // - // Each thread colors a chunk of vertices to prevent all vertices getting the same color. - // - // This version uses a bool array of size FORBIDDEN_SIZE. - // - // param: ii = vertex id - // - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t &thread) const - { - nnz_lno_t chunk_id = thread.league_rank() * thread.team_size() + thread.team_rank(); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, _chunkSize), [&](const nnz_lno_t ichunk) - { - if(chunk_id * _chunkSize + ichunk < _vertexListLength) - { - const nnz_lno_t vid = _vertexList(chunk_id * _chunkSize + ichunk); - - // Already colored this vertex. - if(_colors(vid) <= 0) - { - bool foundColor = false; // Have we found a valid color? - - // Use forbidden array to find available color. - // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - // - If more levels of parallelism are added in the loops over neighbors, then - // atomics will be necessary for updating this. - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors - - // Do multiple passes if the array is too small. - // * TODO: Determine a decent cap for this loop to prevent infinite loops (or prove infinite loop can't happen). - color_t offset = 0; - - while(!foundColor && offset < nv) - { - // initialize - for(int j = 0; j < VB_D2_COLORING_FORBIDDEN_SIZE; j++) { forbidden[j] = false; } - - // If the offset is 0 then we're looking at colors 0..63, but color 0 is reserved for - // UNCOLORED vertices so we should start coloring at 1. - if(0 == offset) - { - forbidden[0] = true; - } - - // Check neighbors, fill forbidden array. - for(size_type vid_d1_adj = _idx(vid); vid_d1_adj < _idx(vid + 1); vid_d1_adj++) - { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - - // Loop over distance-2 neighbors - Kokkos::parallel_for(Kokkos::ThreadVectorRange(thread, _t_idx(vid_d1 + 1) - _t_idx(vid_d1)), [&](const size_type &idx) - { - //const size_type vid_d2_adj = idx + _t_idx(vid); - const size_type vid_d2_adj = _t_idx(vid_d1) + idx; - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); - - // Skip distance-2 self loops - if(vid_d2 != vid && vid_d2 < nv) - { - const color_t c = _colors(vid_d2); - - // If color found is inside current 'range' then mark it as used. - if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) - { - Kokkos::atomic_fetch_or(&forbidden[c - offset], true); - } - } - }); // for vid_d2_adj... - thread.team_barrier(); - } // for vid_d1_adj... - - // color vertex i with smallest available color (firstFit) - for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) - { - if(!forbidden[c]) - { - _colors(vid) = offset + c; - foundColor = true; - break; - } - } // for c... - offset += VB_D2_COLORING_FORBIDDEN_SIZE; - } // while(!foundColor) - } // if _colors(vid) <= 0 ... - } // if chunk_id*... - }); // for ichunk... - } // operator() (end) - }; // struct functorGreedyColorVBTPVR2 (end) -#endif - template struct functorFindConflicts_Atomic From 003b946f59000226afbec9e36b1f5fff918f50d3 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 1 Nov 2018 09:40:28 -0600 Subject: [PATCH 061/190] KokkosBatched - eigen solver working version --- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 148 ++++++++++++----- .../KokkosBatched_Francis_Serial_Internal.hpp | 153 ++++++++++++++++++ ...Batched_WilkinsonShift_Serial_Internal.hpp | 14 +- 3 files changed, 269 insertions(+), 46 deletions(-) create mode 100644 src/batched/KokkosBatched_Francis_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index 50c037b32b..c0ee252431 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -7,6 +7,7 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_WilkinsonShift_Serial_Internal.hpp" #include "KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp" +#include "KokkosBatched_Francis_Serial_Internal.hpp" namespace KokkosBatched { namespace Experimental { @@ -22,28 +23,53 @@ namespace KokkosBatched { static int invoke(const int m, /* */ ValueType * H, const int hs0, const int hs1, + /* */ Kokkos::complex * e, const int es, const int max_iteration = 1000) { typedef ValueType value_type; typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + const mag_type tol = 10000*Kokkos::Details::ArithTraits::epsilon(); + const value_type zero(0), nan(Kokkos::Details::ArithTraits::nan()); - const value_type zero(0); - const mag_type tol = 1000*Kokkos::Details::ArithTraits::epsilon(); + + // printf("Hessenberg\n"); + // for (int i=0;i(H[0],zero); + break; + } + case 2: { + // compute eigenvalues from the characteristic determinant equation + bool is_complex; + SerialWilkinsonShiftInternal::invoke(H[0*hs0+0*hs1], H[0*hs0+1*hs1], + H[1*hs0+0*hs1], H[1*hs0+1*hs1], + e, e+es, + &is_complex); + break; + } default: { - // when m > 2; first test use implicit hessenberg qr step + /// 0. clean eigenvalue array with Nan + for (int i=0;i(nan,zero); + + // when m > 2, use the francis method (or implicit hessenberg qr method for testing) const int hs = hs0+hs1; int iter(0); bool converge = false; while (!converge && iter < max_iteration) { - /// 0. find a subsystem to compute eigenvalues + /// 1. find a subsystem to compute eigenvalues which are not converged yet int cnt = 1; // - find mbeg (first nonzero subdiag value) @@ -62,49 +88,91 @@ namespace KokkosBatched { const int mend = cnt; // if there exist non-converged eigen values - //printf("iter %d mbeg %d mend %d\n", iter, mbeg, mend); - if (mbeg < mend && mbeg < (m-1)) { - /// 1. find shift - value_type shift; + if (mbeg < (mend-1)) { // && mbeg < (m-1)) { +# if 1 { - /// case 0. No shift (testing only) - //shift = zero; - - /// case 1. Rayleigh quotient shift (all eigenvalues are real; testing only) - shift = *(H+(mend-1)*hs); - - /// case 2. Wilkinson shift (francis algorithm) - // value_type lambda1, lambda2; - // bool is_complex; - // SerialWilkinsonShiftInternal::invoke(last_2x2[0*hs0+0*hs1], last_2x2[0*hs0+1*hs1], - // last_2x2[1*hs0+0*hs1], last_2x2[1*hs0+1*hs1], - // &lambda1, &lambda2, - // &is_complex); - - // const auto target = last_2x2[1*hs0+1*hs1]; - // shift = ( Kokkos::Details::ArithTraits::abs(target - lambda1) > - // Kokkos::Details::ArithTraits::abs(target - lambda2) ? lambda2 : lambda1 ); + /// Rayleigh quotient shift (all eigenvalues are real; testing only) + const value_type shift = *(H+(mend-1)*hs); + + /// QR sweep + SerialHessenbergQR_WithShiftInternal::invoke(mend-mbeg, + H+hs*mbeg, hs0, hs1, + shift); + value_type *sub2x2 = H+(mend-2)*hs; + if (Kokkos::Details::ArithTraits::abs(*(sub2x2+hs0)) < tol) { + e[(mend-1)*es] = sub2x2[1*hs0+1*hs1]; + printf(" --- single found at %d,%d, value = %e %e\n", mbeg, mend, e[(mend-1)*es].real(), e[(mend-1)*es].imag()); + } } - - /// 2. QR sweep - SerialHessenbergQR_WithShiftInternal::invoke(mend-mbeg, - H+hs*mbeg, hs0, hs1, - shift); +# endif + +# if 0 + { + /// find a complex eigen pair + Kokkos::complex lambda1, lambda2; + bool is_complex; + value_type *sub2x2 = H+(mend-2)*hs; + SerialWilkinsonShiftInternal::invoke(sub2x2[0*hs0+0*hs1], sub2x2[0*hs0+1*hs1], + sub2x2[1*hs0+0*hs1], sub2x2[1*hs0+1*hs1], + &lambda1, &lambda2, + &is_complex); + + if ((mend-mbeg) == 2) { + /// short cut: eigenvalues are from wilkinson shift + sub2x2[1*hs0+0*hs1] = zero; + e[mbeg+0*es] = lambda1; + e[mbeg+1*es] = lambda2; + + printf(" --- 2x2 found at %d, value = %e %e\n", (mbeg+1), e[(mbeg+1)*es].real(), e[(mbeg+1)*es].imag()); + printf(" --- 2x2 found at %d, value = %e %e\n", (mbeg), e[(mbeg )*es].real(), e[(mbeg )*es].imag()); + } else { + /// Francis step + SerialFrancisInternal::invoke(mend-mbeg, + H+hs*mbeg, hs0, hs1, + lambda1, lambda2, + is_complex); + if (Kokkos::Details::ArithTraits::abs(*(sub2x2+hs0)) < tol) { + e[(mend-1)*es] = sub2x2[1*hs0+1*hs1]; + printf(" --- single found at %d, value = %e %e\n", (mend-1), e[(mend-1)*es].real(), e[(mend-1)*es].imag()); + } else if (Kokkos::Details::ArithTraits::abs(*(sub2x2-hs1)) < tol) { + sub2x2[1*hs0+0*hs1] = zero; + e[(mend-1)*es] = lambda1; + e[(mend-2)*es] = lambda2; + + printf(" --- double found at %d, value = %e %e\n", (mend-1), e[(mend-1)*es].real(), e[(mend-1)*es].imag()); + printf(" --- double found at %d, value = %e %e\n", (mend-2), e[(mend-2)*es].real(), e[(mend-2)*es].imag()); + } + } + + // printf("H at iter %d\n", iter); + // for (int i=0;i::isNan(e[i*es].real())) { + printf(" not convering at %d\n", i ); + e[i*es] = Kokkos::complex(H[i*hs],zero); + } } - if (!converge) - Kokkos::abort("Error: eigenvalues are not converged and reached the maximum number of iterations"); - } + if (!converge) { + printf("Error: eigenvalues are not converged and reached the maximum number of iterations\n"); + //Kokkos::abort("Error: eigenvalues are not converged and reached the maximum number of iterations"); + } + break; + } } return 0; } diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp new file mode 100644 index 0000000000..d9773a36bf --- /dev/null +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -0,0 +1,153 @@ +#ifndef __KOKKOSBATCHED_FRANCIS_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_FRAMCIS_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Givens_Serial_Internal.hpp" +#include "KokkosBatched_ApplyGivens_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialFrancisInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * H, const int hs0, const int hs1, + const Kokkos::complex lambda1, + const Kokkos::complex lambda2, + const bool is_complex) { + typedef ValueType value_type; + const int hs = hs0+hs1; + + const value_type zero(0); + + /// Given a strict Hessenberg matrix H (m x m), + /// it computes a single implicit QR step with a given shift + /// - it assumes H has zeros on subdiagonal entries ( + /// givens rotation is defined as G = [gamma -sigma + /// sigma gamma] + /// G' [chi1 chi2]^t = [alpha 0]^T + /// where G is stored as a pair of gamma and sigma + Kokkos::pair G[2]; + + /// 0. compute 1st double shift vector + value_type v[3]; + { + // this needs m>=3 + // v = M e_1 = (H*H - 2 Re(lambda) H + |lambda|^2 I)e_1 + value_type s, t; + const value_type + h00 = H[0*hs0+0*hs1], h01 = H[0*hs0+1*hs1], + h10 = H[1*hs0+0*hs1], h11 = H[1*hs0+1*hs1], + /* */ h21 = H[2*hs0+1*hs1]; + if (is_complex) { + s = 2*lambda1.real(); t = lambda1.real()*lambda1.real()+lambda1.imag()*lambda1.imag(); + } else { + const value_type val = H[(m-1)*hs]; + const auto dist_lambda1 = Kokkos::Details::ArithTraits::abs(lambda1.real() - val); + const auto dist_lambda2 = Kokkos::Details::ArithTraits::abs(lambda2.real() - val); + const value_type lambda = dist_lambda1 < dist_lambda2 ? lambda1.real() : lambda2.real(); + s = 2*lambda; t = lambda*lambda; + } + v[0] = h00*h00+h01*h10 /* H^2 e_1 */ - s*h00 /* 2 Re(lambda) */ + t; + v[1] = h10*h00+h11*h10 /* */ - s*h10; + v[2] = h21*h10; + } + + /// 1. compute the first two givens rotations that introduces a bulge + { + SerialGivensInternal::invoke(v[0], v[1], + &G[0], + &v[0]); + SerialGivensInternal::invoke(v[0], v[2], + &G[1], + &v[0]); + + // apply G' from left + G[0].second = -G[0].second; + G[1].second = -G[1].second; + + const int nn = m; + SerialApplyLeftGivensInternal::invoke (G[0], nn, + H, hs1, + H+1*hs0, hs1); + SerialApplyLeftGivensInternal::invoke (G[1], nn, + H+0*hs0, hs1, + H+2*hs0, hs1); + + // apply (G')' from right + const int mm = m < 4 ? m : 4; + SerialApplyRightGivensInternal::invoke(G[0], mm, + H, hs0, + H+1*hs1, hs0); + SerialApplyRightGivensInternal::invoke(G[1], mm, + H, hs0, + H+2*hs1, hs0); + } + + /// 1. chase the bulge + + // partitions used for loop iteration + Partition2x2 H_part2x2(hs0, hs1); + Partition3x3 H_part3x3(hs0, hs1); + + // initial partition of A where ATL has a zero dimension + H_part2x2.partWithATL(H, m, m, 1, 1); + for (int m_htl=1;m_htl<(m-1);++m_htl) { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + const int n_hbr = m - m_htl; + /// ----------------------------------------------------- + const int nn = m - m_htl; + const int mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; + + value_type *chi1 = H_part3x3.A11-hs1; + value_type *chi2 = chi1+hs0; + SerialGivensInternal::invoke(*chi1, *chi2, + &G[0], + chi1); + *chi2 = zero; + G[0].second = -G[0].second; // transpose + SerialApplyLeftGivensInternal::invoke (G[0], nn, + H_part3x3.A11, hs1, + H_part3x3.A21, hs1); + SerialApplyRightGivensInternal::invoke(G[0], mm, + H_part3x3.A01, hs0, + H_part3x3.A02, hs0); + + if (nn > 2) { + value_type *chi3 = chi2+hs0; + SerialGivensInternal::invoke(*chi1, *chi3, + &G[1], + chi1); + *chi3 = zero; + G[1].second = -G[1].second; // transpose + SerialApplyLeftGivensInternal::invoke (G[1], nn, + H_part3x3.A11, hs1, + H_part3x3.A21+hs0, hs1); + SerialApplyRightGivensInternal::invoke(G[1], mm, + H_part3x3.A01, hs0, + H_part3x3.A02+hs1, hs0); + } + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); + } + + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp index afdc7d8aec..ec1773a3a6 100644 --- a/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp @@ -21,8 +21,8 @@ namespace KokkosBatched { static int invoke(const ValueType a, const ValueType b, const ValueType c, const ValueType d, - /* */ ValueType * lambda1, - /* */ ValueType * lambda2, + /* */ Kokkos::complex * lambda1, + /* */ Kokkos::complex * lambda2, /* */ bool * is_complex) { /// compute eigenvalues of 2x2 system [a b; /// c d] @@ -33,21 +33,23 @@ namespace KokkosBatched { /// lambda1 := lambda1 + lambda2 /// lambda2 := lambda1 * lambda2 typedef ValueType value_type; + const value_type half(0.5), two(2); const value_type p = (a+d)*half; const value_type q = (b*c-a*d); const value_type v = p*p+q; + if (v < 0) { // complex const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(-v); - *lambda1 = two*p; - *lambda2 = two*p*p+q; + *lambda1 = Kokkos::complex(p, sqrt_v); + *lambda2 = Kokkos::complex(p,-sqrt_v); *is_complex = true; } else { // real const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(v); - *lambda1 = p+sqrt_v; - *lambda2 = p-sqrt_v; + *lambda1 = Kokkos::complex(p+sqrt_v); + *lambda2 = Kokkos::complex(p-sqrt_v); *is_complex = false; } return 0; From c9b5b8821e6a7face3a465e36bb12d273ec57748 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 1 Nov 2018 11:12:26 -0600 Subject: [PATCH 062/190] KokkosBatched - francis step --- src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index c0ee252431..5c65402689 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -89,7 +89,7 @@ namespace KokkosBatched { // if there exist non-converged eigen values if (mbeg < (mend-1)) { // && mbeg < (m-1)) { -# if 1 +# if 0 { /// Rayleigh quotient shift (all eigenvalues are real; testing only) const value_type shift = *(H+(mend-1)*hs); @@ -106,7 +106,7 @@ namespace KokkosBatched { } # endif -# if 0 +# if 1 { /// find a complex eigen pair Kokkos::complex lambda1, lambda2; From e35a88c212850180249448b11aa2e7752586b316 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 1 Nov 2018 13:27:30 -0600 Subject: [PATCH 063/190] KokkosBatched - clean up interface of eigen value solver --- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 233 ++++++++++-------- 1 file changed, 134 insertions(+), 99 deletions(-) diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index 5c65402689..b4b0b03e11 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -18,138 +18,151 @@ namespace KokkosBatched { /// this impl follows the flame interface of householder transformation /// struct SerialEigenvalueInternal { - template + /// Given a strictly Hessenberg matrix H (m x m), this computes all eigenvalues + /// using the Francis method and stores them into a vector e. This routine does + /// not scale nor balance the matrix for the numerical stability. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]H, [in]hs0, [in]hs1 + /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. + /// Entering the routine, H is assumed to have a upper Hessenberg form, where + /// all subdiagonals are zero. The matrix is overwritten on exit. + /// [out]er, [in]ers, [out]ei, [in]eis + /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [in]max_iteration(300) + /// Unlike LAPACK which uses various methods for different types of matrices, + /// this routine uses the Francis method only. A user can set the maximum number + /// of iterations. When it reaches the maximum iteration counts without converging + /// all eigenvalues, the routine returns -1. + /// [in]user_tolerence(-1) + /// If |value| < tolerence*|reference value|, then the value is considered as zero. + /// By default, it uses 1e5*(machie epsilon). + /// [in]restart(false) + /// With a restart option, the routine assume that the matrix H and the vector e + /// contain the partial results from the previous run. When m = 1 or 2, this option + /// won't work as the routine always computes the all eigenvalues. + template KOKKOS_INLINE_FUNCTION static int invoke(const int m, - /* */ ValueType * H, const int hs0, const int hs1, - /* */ Kokkos::complex * e, const int es, - const int max_iteration = 1000) { - typedef ValueType value_type; - typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; - const mag_type tol = 10000*Kokkos::Details::ArithTraits::epsilon(); - const value_type zero(0), nan(Kokkos::Details::ArithTraits::nan()); - - - // printf("Hessenberg\n"); - // for (int i=0;i(H[0],zero); - break; + /* */ RealType * H, const int hs0, const int hs1, + /* */ RealType * er, const int ers, + /* */ RealType * ei, const int eis, + const int max_iteration = 300, + const RealType user_tolerence = RealType(-1), + const bool restart = false) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type zero(0), nan(ats::nan()); + const real_type tol = ( user_tolerence < 0 ? + 1e5*ats::epsilon() : user_tolerence); + + int r_val = 0; + if (restart) { + if (m <= 2) { + Kokkos::abort("Error: restart option cannot be used for m=1 or m=2"); + } + } else { + for (int i=0;i lambda1, lambda2; SerialWilkinsonShiftInternal::invoke(H[0*hs0+0*hs1], H[0*hs0+1*hs1], H[1*hs0+0*hs1], H[1*hs0+1*hs1], - e, e+es, + &lambda1, &lambda2, &is_complex); + er[0] = lambda1.real(); ei[0] = lambda1.imag(); + er[1] = lambda2.real(); ei[1] = lambda2.imag(); break; } default: { - /// 0. clean eigenvalue array with Nan - for (int i=0;i(nan,zero); - - // when m > 2, use the francis method (or implicit hessenberg qr method for testing) - const int hs = hs0+hs1; - int iter(0); - bool converge = false; + /// Francis method + const int hs = hs0+hs1; /// diagonal stride + int iter(0); /// iteration count + bool converge = false; /// bool to check all eigenvalues are converged + while (!converge && iter < max_iteration) { - /// 1. find a subsystem to compute eigenvalues which are not converged yet + /// Step 1: find a set of unrevealed eigenvalues int cnt = 1; - // - find mbeg (first nonzero subdiag value) + /// find mbeg (first nonzero subdiag value) for (;cnt::abs(val) > tol) break; + const auto val = ats::abs(*(H+cnt*hs-hs1)); + const auto ref_val = ats::abs(*(H+cnt*hs)); + if (val > tol*ref_val) break; } const int mbeg = cnt-1; - // - find mend (first zero subdiag value) + /// find mend (first zero subdiag value) for (;cnt::abs(val) < tol) break; + const auto val = ats::abs(*(H+cnt*hs-hs1)); + const auto ref_val = ats::abs(*(H+cnt*hs)); + if (val < tol*ref_val) break; } const int mend = cnt; - // if there exist non-converged eigen values - if (mbeg < (mend-1)) { // && mbeg < (m-1)) { -# if 0 + /// Step 2: if there exist non-converged eigen values + if (mbeg < (mend-1)) { +# if 0 /// implicit QR with shift for testing { - /// Rayleigh quotient shift (all eigenvalues are real; testing only) - const value_type shift = *(H+(mend-1)*hs); - - /// QR sweep + /// Rayleigh quotient shift + const real_type shift = *(H+(mend-1)*hs); SerialHessenbergQR_WithShiftInternal::invoke(mend-mbeg, H+hs*mbeg, hs0, hs1, shift); - value_type *sub2x2 = H+(mend-2)*hs; - if (Kokkos::Details::ArithTraits::abs(*(sub2x2+hs0)) < tol) { - e[(mend-1)*es] = sub2x2[1*hs0+1*hs1]; - printf(" --- single found at %d,%d, value = %e %e\n", mbeg, mend, e[(mend-1)*es].real(), e[(mend-1)*es].imag()); - } + real_type *sub2x2 = H+(mend-2)*hs; + const auto val = ats::abs(sub2x2[hs0]); + const auto ref_val = ats::abs(sub2x2[hs]); + if (val < tol*ref_val) { /// this eigenvalue converges + er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; + } } # endif -# if 1 +# if 1 /// Francis double shift method { /// find a complex eigen pair - Kokkos::complex lambda1, lambda2; + Kokkos::complex lambda1, lambda2; bool is_complex; - value_type *sub2x2 = H+(mend-2)*hs; + real_type *sub2x2 = H+(mend-2)*hs; SerialWilkinsonShiftInternal::invoke(sub2x2[0*hs0+0*hs1], sub2x2[0*hs0+1*hs1], sub2x2[1*hs0+0*hs1], sub2x2[1*hs0+1*hs1], &lambda1, &lambda2, &is_complex); if ((mend-mbeg) == 2) { - /// short cut: eigenvalues are from wilkinson shift + /// eigenvalues are from wilkinson shift + er[(mbeg+0)*ers] = lambda1.real(); ei[(mbeg+0)*eis] = lambda1.imag(); + er[(mbeg+1)*ers] = lambda2.real(); ei[(mbeg+1)*eis] = lambda2.imag(); sub2x2[1*hs0+0*hs1] = zero; - e[mbeg+0*es] = lambda1; - e[mbeg+1*es] = lambda2; - - printf(" --- 2x2 found at %d, value = %e %e\n", (mbeg+1), e[(mbeg+1)*es].real(), e[(mbeg+1)*es].imag()); - printf(" --- 2x2 found at %d, value = %e %e\n", (mbeg), e[(mbeg )*es].real(), e[(mbeg )*es].imag()); } else { - /// Francis step SerialFrancisInternal::invoke(mend-mbeg, H+hs*mbeg, hs0, hs1, lambda1, lambda2, is_complex); - if (Kokkos::Details::ArithTraits::abs(*(sub2x2+hs0)) < tol) { - e[(mend-1)*es] = sub2x2[1*hs0+1*hs1]; - printf(" --- single found at %d, value = %e %e\n", (mend-1), e[(mend-1)*es].real(), e[(mend-1)*es].imag()); - } else if (Kokkos::Details::ArithTraits::abs(*(sub2x2-hs1)) < tol) { - sub2x2[1*hs0+0*hs1] = zero; - e[(mend-1)*es] = lambda1; - e[(mend-2)*es] = lambda2; - - printf(" --- double found at %d, value = %e %e\n", (mend-1), e[(mend-1)*es].real(), e[(mend-1)*es].imag()); - printf(" --- double found at %d, value = %e %e\n", (mend-2), e[(mend-2)*es].real(), e[(mend-2)*es].imag()); + const auto val1 = ats::abs(*(sub2x2+hs0)); + const auto val2 = ats::abs(*(sub2x2-hs1)); + const auto ref_val1 = ats::abs(*(sub2x2+hs )); + const auto ref_val2 = ats::abs(*(sub2x2 )); + + if (val1 < tol*ref_val1) { + er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; + } else if (val2 < tol*(ref_val1+ref_val2)) { + er[(mend-1)*ers] = lambda1.real(); ei[(mend-1)*eis] = lambda1.imag(); + er[(mend-2)*ers] = lambda2.real(); ei[(mend-2)*eis] = lambda2.imag(); + sub2x2[hs0] = zero; // consider two eigenvalues are converged } } - - // printf("H at iter %d\n", iter); - // for (int i=0;i::isNan(e[i*es].real())) { - printf(" not convering at %d\n", i ); - e[i*es] = Kokkos::complex(H[i*hs],zero); - } - } - if (!converge) { - printf("Error: eigenvalues are not converged and reached the maximum number of iterations\n"); - //Kokkos::abort("Error: eigenvalues are not converged and reached the maximum number of iterations"); + /// Step 3: record missing real eigenvalues from the diagonals + if (converge) { + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType * H, const int hs0, const int hs1, + /* */ Kokkos::complex * e, const int es, + const int max_iteration = 300, + const RealType user_tolerence = RealType(-1), + const bool restart = false) { + RealType * er = (RealType*)e; + RealType * ei = er+1; + const int two_es = 2*es; + return invoke(m, + H, hs0, hs1, + er, two_es, + ei, two_es, + max_iteration, + user_tolerence, + restart); } }; - }// end namespace Experimental -} // end namespace KokkosBatched + + + }/// end namespace Experimental +} /// end namespace KokkosBatched #endif From 4a539ecf786ba84f9dbd76ad8a860adfe07c011f Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 1 Nov 2018 16:44:26 -0600 Subject: [PATCH 064/190] KokkosBatched - do not use relative tolerence in deflating the matrix it loses accuracy and it does not gain much performnace --- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 48 +++++++++++-------- 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index b4b0b03e11..8ba3f9eb71 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -51,14 +51,15 @@ namespace KokkosBatched { /* */ RealType * H, const int hs0, const int hs1, /* */ RealType * er, const int ers, /* */ RealType * ei, const int eis, - const int max_iteration = 300, const RealType user_tolerence = RealType(-1), - const bool restart = false) { + const bool restart = false, + const int user_max_iteration = -1) { typedef RealType real_type; typedef Kokkos::Details::ArithTraits ats; const real_type zero(0), nan(ats::nan()); const real_type tol = ( user_tolerence < 0 ? 1e5*ats::epsilon() : user_tolerence); + const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; int r_val = 0; if (restart) { @@ -98,16 +99,18 @@ namespace KokkosBatched { /// find mbeg (first nonzero subdiag value) for (;cnt tol*ref_val) break; + /// const auto ref_val = ats::abs(*(H+cnt*hs)); + /// if (val > tol*ref_val) break; + if (val > tol) break; } const int mbeg = cnt-1; /// find mend (first zero subdiag value) for (;cnt Date: Tue, 6 Nov 2018 11:03:03 -0700 Subject: [PATCH 065/190] KokkosBatched - reduce computations in francis step --- .../KokkosBatched_Francis_Serial_Internal.hpp | 70 +++++++++++++------ 1 file changed, 47 insertions(+), 23 deletions(-) diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp index d9773a36bf..6b9d342978 100644 --- a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -76,7 +76,7 @@ namespace KokkosBatched { G[0].second = -G[0].second; G[1].second = -G[1].second; - const int nn = m; + const int nn = 3; //m; SerialApplyLeftGivensInternal::invoke (G[0], nn, H, hs1, H+1*hs0, hs1); @@ -101,14 +101,14 @@ namespace KokkosBatched { Partition3x3 H_part3x3(hs0, hs1); // initial partition of A where ATL has a zero dimension - H_part2x2.partWithATL(H, m, m, 1, 1); - for (int m_htl=1;m_htl<(m-1);++m_htl) { + int m_htl = 1; + H_part2x2.partWithATL(H, m, m, m_htl, m_htl); + for (;m_htl<(m-2);++m_htl) { // part 2x2 into 3x3 H_part3x3.partWithABR(H_part2x2, 1, 1); - const int n_hbr = m - m_htl; /// ----------------------------------------------------- - const int nn = m - m_htl; - const int mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; + const int nn = 3;// ntmp = m-m_htl, nn = ntmp < 3 ? ntmp : 3; // m - m_htl; + const int mm = 4;// mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; value_type *chi1 = H_part3x3.A11-hs1; value_type *chi2 = chi1+hs0; @@ -121,23 +121,47 @@ namespace KokkosBatched { H_part3x3.A11, hs1, H_part3x3.A21, hs1); SerialApplyRightGivensInternal::invoke(G[0], mm, - H_part3x3.A01, hs0, - H_part3x3.A02, hs0); - - if (nn > 2) { - value_type *chi3 = chi2+hs0; - SerialGivensInternal::invoke(*chi1, *chi3, - &G[1], - chi1); - *chi3 = zero; - G[1].second = -G[1].second; // transpose - SerialApplyLeftGivensInternal::invoke (G[1], nn, - H_part3x3.A11, hs1, - H_part3x3.A21+hs0, hs1); - SerialApplyRightGivensInternal::invoke(G[1], mm, - H_part3x3.A01, hs0, - H_part3x3.A02+hs1, hs0); - } + H_part3x3.A11, hs0, + H_part3x3.A12, hs0); + + value_type *chi3 = chi2+hs0; + SerialGivensInternal::invoke(*chi1, *chi3, + &G[1], + chi1); + *chi3 = zero; + G[1].second = -G[1].second; // transpose + SerialApplyLeftGivensInternal::invoke (G[1], nn, + H_part3x3.A11, hs1, + H_part3x3.A21+hs0, hs1); + SerialApplyRightGivensInternal::invoke(G[1], mm, + H_part3x3.A11, hs0, + H_part3x3.A12+hs1, hs0); + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); + } + + + // last 3x3 block + { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + /// ----------------------------------------------------- + const int nn = 2; //m-m_htl; + const int mm = 2; //mtmp = m; // m_htl+4, mm = mtmp < m ? mtmp : m; + + value_type *chi1 = H_part3x3.A11-hs1; + value_type *chi2 = chi1+hs0; + SerialGivensInternal::invoke(*chi1, *chi2, + &G[0], + chi1); + *chi2 = zero; + G[0].second = -G[0].second; // transpose + SerialApplyLeftGivensInternal::invoke (G[0], nn, + H_part3x3.A11, hs1, + H_part3x3.A21, hs1); + SerialApplyRightGivensInternal::invoke(G[0], mm, + H_part3x3.A11, hs0, + H_part3x3.A12, hs0); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } From d6d5c417fdb4182c295d826696fbdf2a34eaabc2 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 6 Nov 2018 11:43:52 -0700 Subject: [PATCH 066/190] Cleaning up options in d2-wcmclen --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 83 ++++++++++--------- 1 file changed, 42 insertions(+), 41 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 1e645d9f71..380cd33f6a 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -104,30 +104,30 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = << std::endl << spaces << "Parameters:" << std::endl << spaces << " Parallelism (select one of the following):" << std::endl - << spaces << " serial Execute serially." << std::endl - << spaces << " threads Use N posix threads." << std::endl - << spaces << " openmp Use OpenMP with N threads." << std::endl - << spaces << " cuda Use CUDA" << std::endl + << spaces << " --serial Execute serially." << std::endl + << spaces << " --threads Use N posix threads." << std::endl + << spaces << " --openmp Use OpenMP with N threads." << std::endl + << spaces << " --cuda Use CUDA" << std::endl << std::endl << spaces << " Required Parameters:" << std::endl - << spaces << " amtx Input file in Matrix Market format (.mtx)." << std::endl + << spaces << " --amtx Input file in Matrix Market format (.mtx)." << std::endl << std::endl - << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl - << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl + << spaces << " --algorithm Set the algorithm to use. Allowable values are:" << std::endl << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl - << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array." << std::endl + << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl + << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array (Default)." << std::endl << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl << std::endl << spaces << " Optional Parameters:" << std::endl - << spaces << " repeat Set number of test repetitions (Default: 1) " << std::endl - << spaces << " verbose Enable verbose mode (record and print timing + extra information)" << std::endl - << spaces << " chunksize Set the chunk size." << std::endl - << spaces << " dynamic Use dynamic scheduling." << std::endl - << spaces << " teamsize Set the team size." << std::endl - << spaces << " vectorsize Set the vector size." << std::endl - << spaces << " help Print out command line help." << std::endl + << spaces << " --repeat Set number of test repetitions (Default: 1) " << std::endl + << spaces << " --verbose Enable verbose mode (record and print timing + extra information)" << std::endl + << spaces << " --chunksize Set the chunk size." << std::endl + << spaces << " --dynamic Use dynamic scheduling." << std::endl + << spaces << " --teamsize Set the team size." << std::endl + << spaces << " --vectorsize Set the vector size." << std::endl + << spaces << " --help Print out command line help." << std::endl << spaces << " " << std::endl; } @@ -139,52 +139,53 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * for(int i = 1; i < argc; ++i) { - if(0 == strcasecmp(argv[i], "threads")) + if(0 == strcasecmp(argv[i], "--threads")) { params.use_threads = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "serial")) + else if(0 == strcasecmp(argv[i], "--serial")) { params.use_serial = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "openmp")) + else if(0 == strcasecmp(argv[i], "--openmp")) { params.use_openmp = atoi(argv[++i]); + std::cout << "use_openmp = " << params.use_openmp << std::endl; } - else if(0 == strcasecmp(argv[i], "cuda")) + else if(0 == strcasecmp(argv[i], "--cuda")) { params.use_cuda = 1; } - else if(0 == strcasecmp(argv[i], "repeat")) + else if(0 == strcasecmp(argv[i], "--repeat")) { params.repeat = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "chunksize")) + else if(0 == strcasecmp(argv[i], "--chunksize")) { params.chunk_size = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "teamsize")) + else if(0 == strcasecmp(argv[i], "--teamsize")) { params.team_size = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "vectorsize")) + else if(0 == strcasecmp(argv[i], "--vectorsize")) { params.vector_size = atoi(argv[++i]); } - else if(0 == strcasecmp(argv[i], "amtx")) + else if(0 == strcasecmp(argv[i], "--amtx")) { got_required_param_amtx = true; params.a_mtx_bin_file = argv[++i]; } - else if(0 == strcasecmp(argv[i], "dynamic")) + else if(0 == strcasecmp(argv[i], "--dynamic")) { params.use_dynamic_scheduling = 1; } - else if(0 == strcasecmp(argv[i], "verbose")) + else if(0 == strcasecmp(argv[i], "--verbose")) { params.verbose = 1; } - else if(0 == strcasecmp(argv[i], "algorithm")) + else if(0 == strcasecmp(argv[i], "--algorithm")) { ++i; if(0 == strcasecmp(argv[i], "COLORING_D2_MATRIX_SQUARED")) @@ -192,24 +193,24 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * params.algorithm = 1; got_required_param_algorithm = true; } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || 0 == strcasecmp(argv[i], "COLORING_D2") ) + else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) { params.algorithm = 2; got_required_param_algorithm = true; } - else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || 0 == strcasecmp(argv[i], "COLORING_D2") ) { - params.algorithm = 8; + params.algorithm = 3; got_required_param_algorithm = true; } else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT")) { - params.algorithm = 9; + params.algorithm = 4; got_required_param_algorithm = true; } else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT_EF")) { - params.algorithm = 10; + params.algorithm = 5; got_required_param_algorithm = true; } else @@ -219,7 +220,7 @@ int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char * return 1; } } - else if(0 == strcasecmp(argv[i], "help") || 0 == strcasecmp(argv[i], "-h")) + else if(0 == strcasecmp(argv[i], "--help") || 0 == strcasecmp(argv[i], "-h")) { print_options(std::cout, argv[0]); return 1; @@ -330,24 +331,24 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) label_algorithm = "COLORING_D2_MATRIX_SQUARED"; break; case 2: - kh.create_graph_coloring_handle(COLORING_D2_VB); - label_algorithm = "COLORING_D2_VB"; - break; - case 8: kh.create_graph_coloring_handle(COLORING_D2_SERIAL); label_algorithm = "COLORING_D2_SERIAL"; break; - case 9: + case 3: + kh.create_graph_coloring_handle(COLORING_D2_VB); + label_algorithm = "COLORING_D2_VB"; + break; + case 4: kh.create_graph_coloring_handle(COLORING_D2_VB_BIT); label_algorithm = "COLORING_D2_VB_BIT"; break; - case 10: + case 5: kh.create_graph_coloring_handle(COLORING_D2_VB_BIT_EF); label_algorithm = "COLORING_D2_VB_BIT_EF"; break; default: - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + kh.create_graph_coloring_handle(COLORING_D2_VB); + label_algorithm = "COLORING_D2_VB"; break; } From 42ebae00fedac042c8fa2e562393653078782e06 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 7 Nov 2018 15:58:15 -0700 Subject: [PATCH 067/190] KokkosBatched - compile time routines for optimization --- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 151 +++++++++++++++++- .../KokkosBatched_Francis_Serial_Internal.hpp | 86 +++------- 2 files changed, 171 insertions(+), 66 deletions(-) diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp index 72f3caeb89..1838a74597 100644 --- a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -15,6 +15,31 @@ namespace KokkosBatched { /// /// this impl follows the flame interface of householder transformation /// + template + struct SerialApplyLeftGivensSizeSpecificInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G, + /* */ ValueType * a1t, const int &a1ts, + /* */ ValueType * a2t, const int &a2ts) { + typedef ValueType value_type; + const value_type gamma = G.first; + const value_type sigma = G.second; +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int j=0;j KOKKOS_INLINE_FUNCTION @@ -24,15 +49,16 @@ namespace KokkosBatched { /* */ ValueType * a1t, const int a1ts, /* */ ValueType * a2t, const int a2ts) { typedef ValueType value_type; - /// G = [ gamma -sigma; /// sigma gamma ]; /// A := G A /// where gamma is G.first and sigma is G.second - + const value_type gamma = G.first; const value_type sigma = G.second; - +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif for (int j=0;j + struct SerialApplyRightGivensSizeSpecificInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G, + /* */ ValueType * a1, const int &a1s, + /* */ ValueType * a2, const int &a2s) { + typedef ValueType value_type; + const value_type gamma = G.first; + const value_type sigma = G.second; +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int i=0;i KOKKOS_INLINE_FUNCTION @@ -52,15 +102,16 @@ namespace KokkosBatched { /* */ ValueType * a1, const int a1s, /* */ ValueType * a2, const int a2s) { typedef ValueType value_type; - /// G = [ gamma -sigma; /// sigma gamma ]; /// A := A G' /// where gamma is G.first and sigma is G.second - + const value_type gamma = G.first; const value_type sigma = G.second; - +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif for (int i=0;i + struct SerialApplyLeftRightGivensSizeSpecificInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G12, + /* */ ValueType *__restrict__ A, const int &as0, const int &as1) { + typedef ValueType value_type; + + const value_type gamma12 = G12.first; + const value_type sigma12 = G12.second; + +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G12, + const Kokkos::pair &G13, + /* */ ValueType *__restrict__ A, const int &as0, const int &as1) { + typedef ValueType value_type; + + const value_type gamma12 = G12.first; + const value_type sigma12 = G12.second; + const value_type gamma13 = G13.first; + const value_type sigma13 = G13.second; + +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int j=0;j::abs(lambda1.real() - val); const auto dist_lambda2 = Kokkos::Details::ArithTraits::abs(lambda2.real() - val); const value_type lambda = dist_lambda1 < dist_lambda2 ? lambda1.real() : lambda2.real(); - s = 2*lambda; t = lambda*lambda; + s = 2*lambda; + t = lambda*lambda; } v[0] = h00*h00+h01*h10 /* H^2 e_1 */ - s*h00 /* 2 Re(lambda) */ + t; v[1] = h10*h00+h11*h10 /* */ - s*h10; @@ -71,27 +73,15 @@ namespace KokkosBatched { SerialGivensInternal::invoke(v[0], v[2], &G[1], &v[0]); - - // apply G' from left - G[0].second = -G[0].second; - G[1].second = -G[1].second; - - const int nn = 3; //m; - SerialApplyLeftGivensInternal::invoke (G[0], nn, - H, hs1, - H+1*hs0, hs1); - SerialApplyLeftGivensInternal::invoke (G[1], nn, - H+0*hs0, hs1, - H+2*hs0, hs1); - - // apply (G')' from right - const int mm = m < 4 ? m : 4; - SerialApplyRightGivensInternal::invoke(G[0], mm, - H, hs0, - H+1*hs1, hs0); - SerialApplyRightGivensInternal::invoke(G[1], mm, - H, hs0, - H+2*hs1, hs0); + // apply G' from left and right + G[0].second *= minus_one; + G[1].second *= minus_one; + if (m < 4) + SerialApplyLeftRightGivensSizeSpecificInternal<3,3> + ::invoke (G[0], G[1], H, hs0, hs1); + else + SerialApplyLeftRightGivensSizeSpecificInternal<4,3> + ::invoke (G[0], G[1], H, hs0, hs1); } /// 1. chase the bulge @@ -107,61 +97,37 @@ namespace KokkosBatched { // part 2x2 into 3x3 H_part3x3.partWithABR(H_part2x2, 1, 1); /// ----------------------------------------------------- - const int nn = 3;// ntmp = m-m_htl, nn = ntmp < 3 ? ntmp : 3; // m - m_htl; - const int mm = 4;// mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; - value_type *chi1 = H_part3x3.A11-hs1; value_type *chi2 = chi1+hs0; + value_type *chi3 = chi2+hs0; + SerialGivensInternal::invoke(*chi1, *chi2, &G[0], - chi1); - *chi2 = zero; - G[0].second = -G[0].second; // transpose - SerialApplyLeftGivensInternal::invoke (G[0], nn, - H_part3x3.A11, hs1, - H_part3x3.A21, hs1); - SerialApplyRightGivensInternal::invoke(G[0], mm, - H_part3x3.A11, hs0, - H_part3x3.A12, hs0); - - value_type *chi3 = chi2+hs0; + chi1); *chi2 = zero; SerialGivensInternal::invoke(*chi1, *chi3, &G[1], - chi1); - *chi3 = zero; - G[1].second = -G[1].second; // transpose - SerialApplyLeftGivensInternal::invoke (G[1], nn, - H_part3x3.A11, hs1, - H_part3x3.A21+hs0, hs1); - SerialApplyRightGivensInternal::invoke(G[1], mm, - H_part3x3.A11, hs0, - H_part3x3.A12+hs1, hs0); + chi1); *chi3 = zero; + G[0].second *= minus_one; + G[1].second *= minus_one; + SerialApplyLeftRightGivensSizeSpecificInternal<4,3> + ::invoke (G[0], G[1], H_part3x3.A11, hs0, hs1); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } - // last 3x3 block { // part 2x2 into 3x3 H_part3x3.partWithABR(H_part2x2, 1, 1); /// ----------------------------------------------------- - const int nn = 2; //m-m_htl; - const int mm = 2; //mtmp = m; // m_htl+4, mm = mtmp < m ? mtmp : m; - value_type *chi1 = H_part3x3.A11-hs1; value_type *chi2 = chi1+hs0; SerialGivensInternal::invoke(*chi1, *chi2, &G[0], - chi1); - *chi2 = zero; - G[0].second = -G[0].second; // transpose - SerialApplyLeftGivensInternal::invoke (G[0], nn, - H_part3x3.A11, hs1, - H_part3x3.A21, hs1); - SerialApplyRightGivensInternal::invoke(G[0], mm, - H_part3x3.A11, hs0, - H_part3x3.A12, hs0); + chi1); *chi2 = zero; + G[0].second *= minus_one; + SerialApplyLeftRightGivensSizeSpecificInternal<2,2> + ::invoke (G[0], H_part3x3.A11, hs0, hs1); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } From 09dfeed272d8ac68a39b99e99c866996ce72ed5a Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 7 Nov 2018 21:31:54 -0700 Subject: [PATCH 068/190] KokkosBatched - too much optimization puts bugs ... optimization is later.... --- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 126 ++++++------------ ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 19 +-- .../KokkosBatched_Francis_Serial_Internal.hpp | 57 +++++--- 3 files changed, 91 insertions(+), 111 deletions(-) diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp index 1838a74597..25cf6b6c92 100644 --- a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -15,31 +15,6 @@ namespace KokkosBatched { /// /// this impl follows the flame interface of householder transformation /// - template - struct SerialApplyLeftGivensSizeSpecificInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair &G, - /* */ ValueType * a1t, const int &a1ts, - /* */ ValueType * a2t, const int &a2ts) { - typedef ValueType value_type; - const value_type gamma = G.first; - const value_type sigma = G.second; -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (int j=0;j KOKKOS_INLINE_FUNCTION @@ -69,30 +44,6 @@ namespace KokkosBatched { } }; - template - struct SerialApplyRightGivensSizeSpecificInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair &G, - /* */ ValueType * a1, const int &a1s, - /* */ ValueType * a2, const int &a2s) { - typedef ValueType value_type; - const value_type gamma = G.first; - const value_type sigma = G.second; -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (int i=0;i KOKKOS_INLINE_FUNCTION @@ -122,14 +73,17 @@ namespace KokkosBatched { } }; - - template - struct SerialApplyLeftRightGivensSizeSpecificInternal { + struct SerialApplyLeftRightGivensInternal { template KOKKOS_INLINE_FUNCTION static int invoke(const Kokkos::pair &G12, - /* */ ValueType *__restrict__ A, const int &as0, const int &as1) { + const int &m, const int &n, + /* */ ValueType *__restrict__ a1t, + /* */ ValueType *__restrict__ a2t, + /* */ ValueType *__restrict__ a1, + /* */ ValueType *__restrict__ a2, + const int &as0, const int &as1) { typedef ValueType value_type; const value_type gamma12 = G12.first; @@ -138,21 +92,21 @@ namespace KokkosBatched { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j &G12, const Kokkos::pair &G13, - /* */ ValueType *__restrict__ A, const int &as0, const int &as1) { + const int &m, const int &n, + /* */ ValueType *__restrict__ a1t, + /* */ ValueType *__restrict__ a2t, + /* */ ValueType *__restrict__ a3t, + /* */ ValueType *__restrict__ a1, + /* */ ValueType *__restrict__ a2, + /* */ ValueType *__restrict__ a3, + const int &as0, const int &as1) { typedef ValueType value_type; const value_type gamma12 = G12.first; @@ -173,42 +134,41 @@ namespace KokkosBatched { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j tol*ref_val) break; + const auto val = ats::abs(*(H+cnt*hs-hs1)); if (val > tol) break; } const int mbeg = cnt-1; /// find mend (first zero subdiag value) for (;cnt G; + // SerialGivensInternal::invoke(sub2x2[0], sub2x2[hs0], + // &G, + // sub2x2); val1 = zero; val2 = zero; } diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp index 6526149c15..ce30cb36ec 100644 --- a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -38,7 +38,7 @@ namespace KokkosBatched { /// G' [chi1 chi2]^t = [alpha 0]^T /// where G is stored as a pair of gamma and sigma Kokkos::pair G[2]; - + /// 0. compute 1st double shift vector value_type v[3]; { @@ -74,14 +74,16 @@ namespace KokkosBatched { &G[1], &v[0]); // apply G' from left and right - G[0].second *= minus_one; - G[1].second *= minus_one; - if (m < 4) - SerialApplyLeftRightGivensSizeSpecificInternal<3,3> - ::invoke (G[0], G[1], H, hs0, hs1); - else - SerialApplyLeftRightGivensSizeSpecificInternal<4,3> - ::invoke (G[0], G[1], H, hs0, hs1); + G[0].second = -G[0].second; + G[1].second = -G[1].second; + + const int mm = m < 4 ? m : 4, nn = m; + SerialApplyLeftRightGivensInternal + ::invoke (G[0], G[1], + mm, nn, + H, H+hs0, H+2*hs0, + H, H+hs1, H+2*hs1, + hs0, hs1); } /// 1. chase the bulge @@ -107,10 +109,23 @@ namespace KokkosBatched { SerialGivensInternal::invoke(*chi1, *chi3, &G[1], chi1); *chi3 = zero; - G[0].second *= minus_one; - G[1].second *= minus_one; - SerialApplyLeftRightGivensSizeSpecificInternal<4,3> - ::invoke (G[0], G[1], H_part3x3.A11, hs0, hs1); + G[0].second = -G[0].second; + G[1].second = -G[1].second; + + const int nn = m-m_htl, mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; + value_type *a1t = H_part3x3.A11; + value_type *a2t = a1t+hs0; + value_type *a3t = a2t+hs0; + value_type *a1 = H_part3x3.A01; + value_type *a2 = a1+hs1; + value_type *a3 = a2+hs1; + + SerialApplyLeftRightGivensInternal + ::invoke (G[0], G[1], + mm, nn, + a1t, a2t, a3t, + a1, a2, a3, + hs0, hs1); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } @@ -125,9 +140,19 @@ namespace KokkosBatched { SerialGivensInternal::invoke(*chi1, *chi2, &G[0], chi1); *chi2 = zero; - G[0].second *= minus_one; - SerialApplyLeftRightGivensSizeSpecificInternal<2,2> - ::invoke (G[0], H_part3x3.A11, hs0, hs1); + G[0].second = -G[0].second; + + const int mm = m, nn = 2; + value_type *a1t = H_part3x3.A11; + value_type *a2t = a1t+hs0; + value_type *a1 = H_part3x3.A01; + value_type *a2 = a1+hs1; + SerialApplyLeftRightGivensInternal + ::invoke (G[0], + mm, nn, + a1t, a2t, + a1, a2, + hs0, hs1); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } From edb83bda9b7244bcbf1c21b7b77675948580c2d0 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 8 Nov 2018 12:11:15 -0700 Subject: [PATCH 069/190] KokkosBatched - a cleanup commit to sync with the csp team --- .../KokkosBatched_Francis_Serial_Internal.hpp | 2 +- ...kosBatched_Householder_Serial_Internal.hpp | 1 - .../KokkosBatched_SetTriangular_Internal.hpp | 40 +++++++++++++++++++ ...Batched_WilkinsonShift_Serial_Internal.hpp | 2 +- 4 files changed, 42 insertions(+), 3 deletions(-) create mode 100644 src/batched/KokkosBatched_SetTriangular_Internal.hpp diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp index ce30cb36ec..aa40a3b0b6 100644 --- a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -28,7 +28,7 @@ namespace KokkosBatched { typedef ValueType value_type; const int hs = hs0+hs1; - const value_type zero(0), minus_one(-1); + const value_type zero(0); /// Given a strict Hessenberg matrix H (m x m), /// it computes a single implicit QR step with a given shift diff --git a/src/batched/KokkosBatched_Householder_Serial_Internal.hpp b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp index 2629971040..208cfaaa45 100644 --- a/src/batched/KokkosBatched_Householder_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp @@ -27,7 +27,6 @@ namespace KokkosBatched { typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; const mag_type zero(0); - const mag_type two(2); const mag_type half(0.5); const mag_type one(1); const mag_type minus_one(-1); diff --git a/src/batched/KokkosBatched_SetTriangular_Internal.hpp b/src/batched/KokkosBatched_SetTriangular_Internal.hpp new file mode 100644 index 0000000000..48c242f9d8 --- /dev/null +++ b/src/batched/KokkosBatched_SetTriangular_Internal.hpp @@ -0,0 +1,40 @@ +#ifndef __KOKKOSBATCHED_SET_TRIANGULAR_INTERNAL_HPP__ +#define __KOKKOSBATCHED_SET_TRIANGULAR_INTERNAL_HPP__ + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + struct SerialSetLowerTriangularInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, const int n, + const int dist, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + for (int j=0;j Date: Mon, 19 Nov 2018 15:28:23 -0700 Subject: [PATCH 070/190] KokkosBatched - compute real eigen vector from schur form --- ...atched_HessenbergFormQ_Serial_Internal.hpp | 17 +-- ...kkosBatched_Hessenberg_Serial_Internal.hpp | 1 + .../KokkosBatched_Normalize_Internal.hpp | 49 +++++++++ ...htEigenvectorFromSchur_Serial_Internal.hpp | 100 ++++++++++++++++++ ...kosBatched_ShiftedTrsv_Serial_Internal.hpp | 91 ++++++++++++++++ src/batched/KokkosBatched_Util.hpp | 15 +++ 6 files changed, 267 insertions(+), 6 deletions(-) create mode 100644 src/batched/KokkosBatched_Normalize_Internal.hpp create mode 100644 src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_ShiftedTrsv_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp index e5d23d9307..dc52f03486 100644 --- a/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp @@ -5,6 +5,7 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) #include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Set_Internal.hpp" #include "KokkosBatched_SetIdentity_Internal.hpp" #include "KokkosBatched_ApplyQ_Serial_Internal.hpp" @@ -16,7 +17,7 @@ namespace KokkosBatched { /// /// this impl follows the flame interface of householder transformation /// - struct SerialQR_FormQInternal { + struct SerialHessenbergFormQInternal { template KOKKOS_INLINE_FUNCTION static int @@ -31,18 +32,22 @@ namespace KokkosBatched { /// Given a matrix A that includes Hessenberg factorization /// it forms a unitary matrix Q - /// B = Q = (H0 H1 H2 H3 ... H(k-1)) I + /// B = Q = (H0 H1 H2 H3 ... H(k-2)) I /// where - /// A is m x k (holding H0, H1 ... H(k-1) + /// A is m x k (holding H0, H1 ... H(k-2) /// t is k x 1 /// B is m x m // set identity - SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + if (is_Q_zero) + SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); + else + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + return SerialApplyQ_LeftNoTransForwardInternal - ::invoke(m-1, m-1, k, + ::invoke(m-1, m-1, k-1, A+as0, as0, as1, t, ts, - Q+qs0+qs1, qs0, qs1, + Q+qs0+qs1, qs1, qs0, w); } }; diff --git a/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp index 141aafd041..5bd6b0cd13 100644 --- a/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp @@ -29,6 +29,7 @@ namespace KokkosBatched { /// Given a matrix A, it computes hessenberg decomposition of the matrix /// - t is to store tau and w is for workspace + /// - H = Q^H A Q and A = Q H Q^H // partitions used for loop iteration Partition2x2 A_part2x2(as0, as1); diff --git a/src/batched/KokkosBatched_Normalize_Internal.hpp b/src/batched/KokkosBatched_Normalize_Internal.hpp new file mode 100644 index 0000000000..0cf10d4a79 --- /dev/null +++ b/src/batched/KokkosBatched_Normalize_Internal.hpp @@ -0,0 +1,49 @@ +#ifndef __KOKKOSBATCHED_NORMALIZE_INTERNAL_HPP__ +#define __KOKKOSBATCHED_NORMALIZE_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + struct SerialNormalizeInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType *__restrict__ v, const int vs) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; + + mag_type norm(0); +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * S, const int ss0, const int ss1, + /* */ ValueType * V, const int vs0, const int vs1) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; + const value_type zero(0), one(1); + + /// partitions used for loop iteration + Partition2x2 S_part2x2(ss0, ss1); + Partition3x3 S_part3x3(ss0, ss1); + + Partition1x2 V_part1x2(vs1); + Partition1x3 V_part1x3(vs1); + + /// initial partition of S where ABR has a zero dimension + S_part2x2.partWithABR(S, m, m, 0, 0); + V_part1x2.partWithAR(V, m, 0); + + const mag_type tol = ats::epsilon(); + int m_stl = m; + for (;m_stl>0;) { + const value_type subdiag = ats::abs(*(S_part2x2.ABR-ss0-2*ss1)); + if (subdiag < tol) { + /// part 2x2 into 3x3 + S_part3x3.partWithATL(S_part2x2, 1, 1); + V_part1x3.partWithAL(V_part1x2, 1); + /// --------------------------------------------------- + /// real eigenvalue + const value_type lambda = *S_part3x3.A11; + + /// initialize a right eigen vector + for (int i=0;i<(m_stl-1);++i) V_part1x3.A1[i*vs0] = -S_part3x3.A01[i*ss0]; + V_part1x3.A1[(m_stl-1)*vs0] = one; + for (int i=m_stl;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType lambda, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + for (int p=0;p + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType lambda, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + ValueType *__restrict__ b0 = b; + for (int p=(m-1);p>=0;--p) { + const int iend = p; + + const ValueType *__restrict__ a01 = A+p*as1; + /**/ ValueType *__restrict__ beta1 = b+p*bs0; + + // with __restrict__ a compiler assumes that the pointer is not accessed by others + // op(/=) uses this pointer and changes the associated values, which brings a compiler problem + *beta1 = *beta1 / (A[p*as0+p*as1] - lambda); + + for (int i=0;i &part) { AL = part.A0; AR = part.A2; } + + // A0 A1 are merged into AL + KOKKOS_INLINE_FUNCTION + void mergeToAR(const Partition1x3 &part) { + AL = part.A0; AR = part.A1; + } }; template @@ -389,6 +400,10 @@ namespace KokkosBatched { Partition1x3(const int arg_as1) : as1(arg_as1), A0(NULL), A1(NULL), A2(NULL) {} + KOKKOS_INLINE_FUNCTION + void partWithAL(const Partition1x2 &part, const int mA1) { + A0 = part.AL; A2 = part.AR; A1 = A2 - mA1*as1; + } KOKKOS_INLINE_FUNCTION void partWithAR(const Partition1x2 &part, const int mA1) { A0 = part.AL; A1 = part.AR; A2 = A1 + mA1*as1; From 6dd6d8a464a1bd4cf2fcc2fa30d30d969b5f4c80 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 19 Nov 2018 17:50:02 -0700 Subject: [PATCH 071/190] KokkosBatched - complex eigenvectors are computed --- .../KokkosBatched_Normalize_Internal.hpp | 5 +- ...htEigenvectorFromSchur_Serial_Internal.hpp | 82 +++++++++++++++---- ...kosBatched_ShiftedTrsv_Serial_Internal.hpp | 24 +++--- 3 files changed, 79 insertions(+), 32 deletions(-) diff --git a/src/batched/KokkosBatched_Normalize_Internal.hpp b/src/batched/KokkosBatched_Normalize_Internal.hpp index 0cf10d4a79..abc25fdb51 100644 --- a/src/batched/KokkosBatched_Normalize_Internal.hpp +++ b/src/batched/KokkosBatched_Normalize_Internal.hpp @@ -30,12 +30,11 @@ namespace KokkosBatched { const auto v_at_i = v[i*vs]; norm += ats::real(v_at_i*ats::conj(v_at_i)); } - norm = ats::sqrt(norm); - + norm = Kokkos::Details::ArithTraits::sqrt(norm); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i KOKKOS_INLINE_FUNCTION static int invoke(const int m, /* */ ValueType * S, const int ss0, const int ss1, - /* */ ValueType * V, const int vs0, const int vs1) { + /* */ ValueType * V, const int vs0, const int vs1, + /* */ ValueType * w) { typedef ValueType value_type; typedef Kokkos::Details::ArithTraits ats; typedef typename ats::mag_type mag_type; + typedef Kokkos::complex complex_type; + const value_type zero(0), one(1); /// partitions used for loop iteration @@ -54,35 +59,76 @@ namespace KokkosBatched { int m_stl = m; for (;m_stl>0;) { const value_type subdiag = ats::abs(*(S_part2x2.ABR-ss0-2*ss1)); - if (subdiag < tol) { - /// part 2x2 into 3x3 - S_part3x3.partWithATL(S_part2x2, 1, 1); - V_part1x3.partWithAL(V_part1x2, 1); - /// --------------------------------------------------- + + /// part 2x2 into 3x3 + const bool subdiag_is_zero = subdiag < tol; + const int mA11 = subdiag_is_zero ? 1 : 2; + S_part3x3.partWithATL(S_part2x2, mA11, mA11); + V_part1x3.partWithAL(V_part1x2, mA11); + + if (subdiag_is_zero) { /// real eigenvalue const value_type lambda = *S_part3x3.A11; /// initialize a right eigen vector - for (int i=0;i<(m_stl-1);++i) V_part1x3.A1[i*vs0] = -S_part3x3.A01[i*ss0]; - V_part1x3.A1[(m_stl-1)*vs0] = one; - for (int i=m_stl;i + typename ValueTypeA, + typename ValueTypeB> KOKKOS_INLINE_FUNCTION static int invoke(const int m, const ScalarType lambda, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { + const ValueTypeA *__restrict__ A, const int as0, const int as1, + /**/ ValueTypeB *__restrict__ b, const int bs0) { for (int p=0;p + typename ValueTypeA, + typename ValueTypeB> KOKKOS_INLINE_FUNCTION static int invoke(const int m, const ScalarType lambda, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - ValueType *__restrict__ b0 = b; + const ValueTypeA *__restrict__ A, const int as0, const int as1, + /**/ ValueTypeB *__restrict__ b, const int bs0) { + ValueTypeB *__restrict__ b0 = b; for (int p=(m-1);p>=0;--p) { const int iend = p; - const ValueType *__restrict__ a01 = A+p*as1; - /**/ ValueType *__restrict__ beta1 = b+p*bs0; + const ValueTypeA *__restrict__ a01 = A+p*as1; + /**/ ValueTypeB *__restrict__ beta1 = b+p*bs0; // with __restrict__ a compiler assumes that the pointer is not accessed by others // op(/=) uses this pointer and changes the associated values, which brings a compiler problem From 81884cf87ccd818eaa4c9a7400dc877252e22f01 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 20 Nov 2018 17:21:09 -0700 Subject: [PATCH 072/190] KokkosBatched - compute schur decomposition A = ZTZ^H T = Z^HAZ now I need to accumultate the givens rotations to construct Z --- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 4 + ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 143 ++++++++++++++---- .../KokkosBatched_Francis_Serial_Internal.hpp | 23 +-- ...HessenbergQR_WithShift_Serial_Internal.hpp | 26 ++-- ...KokkosBatched_Schur2x2_Serial_Internal.hpp | 129 ++++++++++++++++ 5 files changed, 273 insertions(+), 52 deletions(-) create mode 100644 src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp index 25cf6b6c92..0bd48d579b 100644 --- a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -23,6 +23,7 @@ namespace KokkosBatched { const int n, /* */ ValueType * a1t, const int a1ts, /* */ ValueType * a2t, const int a2ts) { + if (n == 0) return 0; // quick return typedef ValueType value_type; /// G = [ gamma -sigma; /// sigma gamma ]; @@ -52,6 +53,7 @@ namespace KokkosBatched { const int m, /* */ ValueType * a1, const int a1s, /* */ ValueType * a2, const int a2s) { + if (m == 0) return 0; // quick return typedef ValueType value_type; /// G = [ gamma -sigma; /// sigma gamma ]; @@ -84,6 +86,7 @@ namespace KokkosBatched { /* */ ValueType *__restrict__ a1, /* */ ValueType *__restrict__ a2, const int &as0, const int &as1) { + if (m == 0 && n == 0) return 0; // quick return typedef ValueType value_type; const value_type gamma12 = G12.first; @@ -124,6 +127,7 @@ namespace KokkosBatched { /* */ ValueType *__restrict__ a2, /* */ ValueType *__restrict__ a3, const int &as0, const int &as1) { + if (m == 0 && n == 0) return 0; // quick return typedef ValueType value_type; const value_type gamma12 = G12.first; diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index 23a04406bf..cd21bc365b 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -6,6 +6,7 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_WilkinsonShift_Serial_Internal.hpp" +#include "KokkosBatched_Schur2x2_Serial_Internal.hpp" #include "KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp" #include "KokkosBatched_Francis_Serial_Internal.hpp" @@ -51,14 +52,13 @@ namespace KokkosBatched { /* */ RealType * H, const int hs0, const int hs1, /* */ RealType * er, const int ers, /* */ RealType * ei, const int eis, - const RealType user_tolerence = RealType(-1), + /* */ RealType * w, + const bool request_schur, const bool restart = false, const int user_max_iteration = -1) { typedef RealType real_type; typedef Kokkos::Details::ArithTraits ats; - const real_type zero(0), nan(ats::nan()); - const real_type tol = ( user_tolerence < 0 ? - 1e5*ats::epsilon() : user_tolerence); + const real_type zero(0), nan(ats::nan()), tol = 1e2*ats::epsilon(); const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; int r_val = 0; @@ -70,7 +70,10 @@ namespace KokkosBatched { for (int i=0;i lambda1, lambda2; - SerialWilkinsonShiftInternal::invoke(H[0*hs0+0*hs1], H[0*hs0+1*hs1], - H[1*hs0+0*hs1], H[1*hs0+1*hs1], - &lambda1, &lambda2, - &is_complex); + if (request_schur) { + Kokkos::pair G; + SerialSchur2x2Internal::invoke(H, H+hs1, + H+hs0, H+hs, + &G, + &lambda1, &lambda2, + &is_complex); + } else { + SerialWilkinsonShiftInternal::invoke(H[0], H[hs1], + H[hs0], H[hs], + &lambda1, &lambda2, + &is_complex); + } er[0] = lambda1.real(); ei[0] = lambda1.imag(); er[1] = lambda2.real(); ei[1] = lambda2.imag(); break; } default: { /// Francis method - const int hs = hs0+hs1; /// diagonal stride int iter(0); /// iteration count bool converge = false; /// bool to check all eigenvalues are converged @@ -109,16 +120,24 @@ namespace KokkosBatched { if (val < tol) break; } const int mend = cnt; - + const int mdiff = mend - mbeg; + const int mend_minus_two_mult_hs0 = (mend-2)*hs0; + /// Step 2: if there exist non-converged eigen values - if (mbeg < (mend-1)) { + if (1 < mdiff) { # if 0 /// implicit QR with shift for testing { /// Rayleigh quotient shift const real_type shift = *(H+(mend-1)*hs); - SerialHessenbergQR_WithShiftInternal::invoke(mend-mbeg, - H+hs*mbeg, hs0, hs1, - shift); + if (request_schur) { + SerialHessenbergQR_WithShiftInternal::invoke(mbeg, mend, m, + H, hs0, hs1, + shift); + } else { + SerialHessenbergQR_WithShiftInternal::invoke(0, mdiff, mdiff, + H+hs*mbeg, hs0, hs1, + shift); + } real_type *sub2x2 = H+(mend-2)*hs; const auto val = ats::abs(sub2x2[hs0]); if (val < tol) { /// this eigenvalue converges @@ -133,36 +152,86 @@ namespace KokkosBatched { Kokkos::complex lambda1, lambda2; bool is_complex; real_type *sub2x2 = H+(mend-2)*hs; - SerialWilkinsonShiftInternal::invoke(sub2x2[0*hs0+0*hs1], sub2x2[0*hs0+1*hs1], - sub2x2[1*hs0+0*hs1], sub2x2[1*hs0+1*hs1], - &lambda1, &lambda2, - &is_complex); - if ((mend-mbeg) == 2) { + if (2 == mdiff) { + if (request_schur) { + Kokkos::pair G; + SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, + sub2x2+hs0, sub2x2+hs, + &G, + &lambda1, &lambda2, + &is_complex); + subdiags[mend-1] = sub2x2[hs0]; + + /// apply G' from left + G.second = -G.second; + SerialApplyLeftGivensInternal::invoke (G, m-mend, + sub2x2 +2*hs1, hs1, + sub2x2+hs0+2*hs1, hs1); + + /// apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, mend-2, + sub2x2 -mend_minus_two_mult_hs0, hs0, + sub2x2+hs1-mend_minus_two_mult_hs0, hs0); + } else { + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); + } + sub2x2[hs0] = zero; + /// eigenvalues are from wilkinson shift er[(mbeg+0)*ers] = lambda1.real(); ei[(mbeg+0)*eis] = lambda1.imag(); er[(mbeg+1)*ers] = lambda2.real(); ei[(mbeg+1)*eis] = lambda2.imag(); - sub2x2[1*hs0+0*hs1] = zero; } else { - SerialFrancisInternal::invoke(mend-mbeg, - H+hs*mbeg, hs0, hs1, - lambda1, lambda2, - is_complex); + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); + + if (request_schur) { + SerialFrancisInternal::invoke(mbeg, mend, m, + H, hs0, hs1, + lambda1, lambda2, + is_complex); + } else { + SerialFrancisInternal::invoke(0, mdiff, mdiff, + H+hs*mbeg, hs0, hs1, + lambda1, lambda2, + is_complex); + } /* */ auto &val1 = *(sub2x2+hs0); /* */ auto &val2 = *(sub2x2-hs1); const auto abs_val1 = ats::abs(val1); const auto abs_val2 = ats::abs(val2); + /// convergence check if (abs_val1 < tol) { er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; val1 = zero; } else if (abs_val2 < tol) { er[(mend-1)*ers] = lambda1.real(); ei[(mend-1)*eis] = lambda1.imag(); er[(mend-2)*ers] = lambda2.real(); ei[(mend-2)*eis] = lambda2.imag(); - // to preserve schur form, perform temporary givens rotation - // Kokkos::pair G; - // SerialGivensInternal::invoke(sub2x2[0], sub2x2[hs0], - // &G, - // sub2x2); + + /// preserve the standard schur form + Kokkos::pair G; + SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, + sub2x2+hs0, sub2x2+hs, + &G, + &lambda1, &lambda2, + &is_complex); + subdiags[mend-1] = val1; + + /// apply G' from left + G.second = -G.second; + SerialApplyLeftGivensInternal::invoke (G, m-mend, + sub2x2 +2*hs1, hs1, + sub2x2+hs0+2*hs1, hs1); + + // apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, mend-2, + sub2x2 -mend_minus_two_mult_hs0, hs0, + sub2x2+hs1-mend_minus_two_mult_hs0, hs0); val1 = zero; val2 = zero; } @@ -178,9 +247,17 @@ namespace KokkosBatched { } /// Step 3: record missing real eigenvalues from the diagonals if (converge) { - for (int i=0;i KOKKOS_INLINE_FUNCTION static int - invoke(const int m, - /* */ ValueType * H, const int hs0, const int hs1, + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, const Kokkos::complex lambda1, const Kokkos::complex lambda2, const bool is_complex) { @@ -30,6 +30,10 @@ namespace KokkosBatched { const value_type zero(0); + /// redefine variables + const int m = mend-mbeg, mrst = morg-mend, mbeg_mult_hs0 = mbeg*hs0; + ValueType *H = HH+hs*mbeg; + /// Given a strict Hessenberg matrix H (m x m), /// it computes a single implicit QR step with a given shift /// - it assumes H has zeros on subdiagonal entries ( @@ -78,11 +82,12 @@ namespace KokkosBatched { G[1].second = -G[1].second; const int mm = m < 4 ? m : 4, nn = m; + value_type *Hs = H-mbeg_mult_hs0; SerialApplyLeftRightGivensInternal ::invoke (G[0], G[1], - mm, nn, - H, H+hs0, H+2*hs0, - H, H+hs1, H+2*hs1, + mm+mbeg, nn+mrst, + H, H +hs0,H +2*hs0, + Hs, Hs+hs1,Hs+2*hs1, hs0, hs1); } @@ -116,13 +121,13 @@ namespace KokkosBatched { value_type *a1t = H_part3x3.A11; value_type *a2t = a1t+hs0; value_type *a3t = a2t+hs0; - value_type *a1 = H_part3x3.A01; + value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; value_type *a2 = a1+hs1; value_type *a3 = a2+hs1; SerialApplyLeftRightGivensInternal ::invoke (G[0], G[1], - mm, nn, + mm+mbeg, nn+mrst, a1t, a2t, a3t, a1, a2, a3, hs0, hs1); @@ -145,11 +150,11 @@ namespace KokkosBatched { const int mm = m, nn = 2; value_type *a1t = H_part3x3.A11; value_type *a2t = a1t+hs0; - value_type *a1 = H_part3x3.A01; + value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; value_type *a2 = a1+hs1; SerialApplyLeftRightGivensInternal ::invoke (G[0], - mm, nn, + mm+mbeg, nn+mrst, a1t, a2t, a1, a2, hs0, hs1); diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index bb5b3a9557..b3816fb19d 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -20,12 +20,18 @@ namespace KokkosBatched { template KOKKOS_INLINE_FUNCTION static int - invoke(const int m, - /* */ ValueType * H, const int hs0, const int hs1, + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, const ValueType shift) { typedef ValueType value_type; + const int hs = hs0+hs1; + const value_type zero(0); + /// redefine variables + const int m = mend-mbeg, mbeg_mult_hs0 = mbeg*hs0; + ValueType *H = HH+mbeg*hs; + /// Given a strict Hessenberg matrix H (m x m), /// it computes a single implicit QR step with a given shift /// - it assumes H has zeros on subdiagonal entries ( @@ -51,15 +57,15 @@ namespace KokkosBatched { // apply G' from left G.second = -G.second; // transpose G const int nn = m; - SerialApplyLeftGivensInternal::invoke (G, nn, + SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), h11, hs1, h21, hs1); // apply (G')' from right const int mm = m < 3 ? m : 3; - SerialApplyRightGivensInternal::invoke(G, mm, - h11, hs0, - h12, hs0); + SerialApplyRightGivensInternal::invoke(G, mm+mbeg, + h11-mbeg_mult_hs0, hs0, + h12-mbeg_mult_hs0, hs0); } /// 1. chase the bulge @@ -85,13 +91,13 @@ namespace KokkosBatched { G.second = -G.second; // transpose G const int nn = m - m_htl; - SerialApplyLeftGivensInternal::invoke (G, nn, + SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), H_part3x3.A11, hs1, H_part3x3.A21, hs1); const int mtmp = m_htl+3, mm = mtmp < m ? mtmp : m; - SerialApplyRightGivensInternal::invoke(G, mm, - H_part3x3.A01, hs0, - H_part3x3.A02, hs0); + SerialApplyRightGivensInternal::invoke(G, mm+mbeg, + H_part3x3.A01-mbeg_mult_hs0, hs0, + H_part3x3.A02-mbeg_mult_hs0, hs0); /// ----------------------------------------------------- H_part2x2.mergeToATL(H_part3x3); } diff --git a/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp new file mode 100644 index 0000000000..134bac0248 --- /dev/null +++ b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp @@ -0,0 +1,129 @@ +#ifndef __KOKKOSBATCHED_SCHUR2X2_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_SCHUR2X2_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialSchur2x2Internal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(RealType * alpha00, RealType * alpha01, + RealType * alpha10, RealType * alpha11, + Kokkos::pair * G, + Kokkos::complex * lambda1, + Kokkos::complex * lambda2, + bool * is_complex) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type zero(0), one(1), half(0.5), minus_one(-1); + /// compute G = [ gamma -sigma; + /// sigma gamma ]; + /// G.first = gamma and G.second = sigma + /// this rotation satisfy the following + /// G' [alpha00 alpha01 G = [ beta00 beta01; + /// alpha10 alpha11 ] beta10 beta11 ]; + /// where either + /// 1) beta00 = beta11 and beta01*beta10 < 0 + /// 2) beta10 = 0 + const real_type tol = ats::epsilon()*real_type(100); + if (ats::abs(*alpha10) < tol) { + /// no rotation + *G = Kokkos::pair(one, zero); + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else if (ats::abs(*alpha01) < tol) { + /// 90 degree rotation (permutation) + *G = Kokkos::pair(zero, one); + /// [ 0 1 ][alpha00 0 [ 0 -1 --> [ alpha11 -alpha10 + /// -1 0 ] alpha10 alpha11] 1 0] 0 alpha00] + const real_type tmp = *alpha00; *alpha00 = *alpha11; *alpha11 = tmp; + *alpha01 = -(*alpha10); *alpha10 = zero; + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else if (ats::abs(*alpha00-*alpha11) < tol && (*alpha01)*(*alpha10) > zero) { + // no rotation (already the standard schur form) + *G = Kokkos::pair(one, zero); + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else { + /// rotation to equalize diagonals + const real_type a = (*alpha00)-(*alpha11); + const real_type b = (*alpha01)+(*alpha10); + const real_type l = ats::sqrt(a*a+b*b); + const real_type c = ats::sqrt(half*(one+ats::abs(b)/l)); + const real_type s = -((half*a)/(l*c))*(b > zero ? one : minus_one); + *G = Kokkos::pair(c, s); + /// [ gamma sigma ][ alpha00 alpha01 [ gamma -sigma --> [ alpha11 -alpha10 + /// -sigma gamma ] alpha10 alpha11 ] sigma gamma ] 0 alpha00] + const real_type a00 = *alpha00, a01 = *alpha01; + const real_type a10 = *alpha10, a11 = *alpha11; + const real_type cc = c*c, cs = c*s, ss= s*s; + *alpha00 = cc*a00 + cs*a01 + cs*a10 + ss*a11; + *alpha01 = -cs*a00 + cc*a01 - ss*a10 + cs*a11; + *alpha10 = -cs*a00 - ss*a01 + cc*a10 + cs*a11; + *alpha11 = ss*a00 - cs*a01 - cs*a10 + cc*a11; + + const real_type tmp = (*alpha00 + *alpha11)*half; + *alpha00 = tmp; + *alpha11 = tmp; + + const real_type mult_alpha_offdiags = (*alpha10)*(*alpha01); + if (mult_alpha_offdiags > zero) { + /// transforms the matrix into a upper triangular + const real_type sqrt_mult_alpha_offdiags = ats::sqrt(mult_alpha_offdiags); + + /// redefine the rotation matrix + const real_type sqrt_abs_alpha01 = ats::sqrt(ats::abs(*alpha01)); + const real_type sqrt_abs_alpha10 = ats::sqrt(ats::abs(*alpha10)); + const real_type abs_sum_offidags = ats::abs((*alpha01)+(*alpha10)); + const real_type c1 = ats::sqrt(ats::abs(*alpha01)/abs_sum_offidags); + const real_type s1 = ats::sqrt(ats::abs(*alpha10)/abs_sum_offidags); + const real_type sign_alpha10 = *alpha10 > zero ? one : minus_one; + + *G = Kokkos::pair(c*c1-s*s1,c*s1+s*c1); + + /// apply rotation to 2x2 matrix so that alpha10 becomes zero + *alpha00 = tmp + sign_alpha10*sqrt_mult_alpha_offdiags; + *alpha11 = tmp - sign_alpha10*sqrt_mult_alpha_offdiags; + *alpha01 = (*alpha01)-(*alpha10); + *alpha10 = zero; + + // two real eigen values + *lambda1 = Kokkos::complex(*alpha00); + *lambda2 = Kokkos::complex(*alpha11); + *is_complex = false; + } else { + /// two complex eigen values + const real_type sqrt_mult_alpha_offdiags = ats::sqrt(-mult_alpha_offdiags); + *lambda1 = Kokkos::complex(tmp, sqrt_mult_alpha_offdiags); + *lambda2 = Kokkos::complex(lambda1->real(), -lambda1->imag()); + *is_complex = true; + } + } + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif From 5adad132ca5aee360081d093b3132235bab6e3a7 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 26 Nov 2018 14:17:32 -0700 Subject: [PATCH 073/190] KokkosBatched - let's not make eigenvalue interface too much complicated this simplify eigenvalue interface with givens accumulation later need to provide separate interface for schur decomposition --- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 119 ++++-------------- .../KokkosBatched_Francis_Serial_Internal.hpp | 49 +++++++- ...HessenbergQR_WithShift_Serial_Internal.hpp | 40 ++++-- .../KokkosBatched_UpdateGivens_Internal.hpp | 37 ++++++ 4 files changed, 137 insertions(+), 108 deletions(-) create mode 100644 src/batched/KokkosBatched_UpdateGivens_Internal.hpp diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index cd21bc365b..bd1cecb5c8 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -33,18 +33,15 @@ namespace KokkosBatched { /// [out]er, [in]ers, [out]ei, [in]eis /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [in]restart(false) + /// With a restart option, the routine assume that the matrix H and the vector e + /// contain the partial results from the previous run. When m = 1 or 2, this option + /// won't work as the routine always computes the all eigenvalues. /// [in]max_iteration(300) /// Unlike LAPACK which uses various methods for different types of matrices, /// this routine uses the Francis method only. A user can set the maximum number /// of iterations. When it reaches the maximum iteration counts without converging /// all eigenvalues, the routine returns -1. - /// [in]user_tolerence(-1) - /// If |value| < tolerence*|reference value|, then the value is considered as zero. - /// By default, it uses 1e5*(machie epsilon). - /// [in]restart(false) - /// With a restart option, the routine assume that the matrix H and the vector e - /// contain the partial results from the previous run. When m = 1 or 2, this option - /// won't work as the routine always computes the all eigenvalues. template KOKKOS_INLINE_FUNCTION static int @@ -52,8 +49,6 @@ namespace KokkosBatched { /* */ RealType * H, const int hs0, const int hs1, /* */ RealType * er, const int ers, /* */ RealType * ei, const int eis, - /* */ RealType * w, - const bool request_schur, const bool restart = false, const int user_max_iteration = -1) { typedef RealType real_type; @@ -71,8 +66,6 @@ namespace KokkosBatched { er[i*ers] = nan; } - real_type *subdiags = w; - const int hs = hs0+hs1; /// diagonal stride switch (m) { case 0: { /* do nothing */ break; } @@ -81,19 +74,10 @@ namespace KokkosBatched { /// compute eigenvalues from the characteristic determinant equation bool is_complex; Kokkos::complex lambda1, lambda2; - if (request_schur) { - Kokkos::pair G; - SerialSchur2x2Internal::invoke(H, H+hs1, - H+hs0, H+hs, - &G, - &lambda1, &lambda2, - &is_complex); - } else { - SerialWilkinsonShiftInternal::invoke(H[0], H[hs1], - H[hs0], H[hs], - &lambda1, &lambda2, - &is_complex); - } + SerialWilkinsonShiftInternal::invoke(H[0], H[hs1], + H[hs0], H[hs], + &lambda1, &lambda2, + &is_complex); er[0] = lambda1.real(); ei[0] = lambda1.imag(); er[1] = lambda2.real(); ei[1] = lambda2.imag(); break; @@ -121,7 +105,6 @@ namespace KokkosBatched { } const int mend = cnt; const int mdiff = mend - mbeg; - const int mend_minus_two_mult_hs0 = (mend-2)*hs0; /// Step 2: if there exist non-converged eigen values if (1 < mdiff) { @@ -129,15 +112,9 @@ namespace KokkosBatched { { /// Rayleigh quotient shift const real_type shift = *(H+(mend-1)*hs); - if (request_schur) { - SerialHessenbergQR_WithShiftInternal::invoke(mbeg, mend, m, - H, hs0, hs1, - shift); - } else { - SerialHessenbergQR_WithShiftInternal::invoke(0, mdiff, mdiff, - H+hs*mbeg, hs0, hs1, - shift); - } + SerialHessenbergQR_WithShiftInternal::invoke(0, mdiff, mdiff, + H+hs*mbeg, hs0, hs1, + shift); real_type *sub2x2 = H+(mend-2)*hs; const auto val = ats::abs(sub2x2[hs0]); if (val < tol) { /// this eigenvalue converges @@ -153,31 +130,10 @@ namespace KokkosBatched { bool is_complex; real_type *sub2x2 = H+(mend-2)*hs; if (2 == mdiff) { - if (request_schur) { - Kokkos::pair G; - SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, - sub2x2+hs0, sub2x2+hs, - &G, - &lambda1, &lambda2, - &is_complex); - subdiags[mend-1] = sub2x2[hs0]; - - /// apply G' from left - G.second = -G.second; - SerialApplyLeftGivensInternal::invoke (G, m-mend, - sub2x2 +2*hs1, hs1, - sub2x2+hs0+2*hs1, hs1); - - /// apply (G')' from right - SerialApplyRightGivensInternal::invoke(G, mend-2, - sub2x2 -mend_minus_two_mult_hs0, hs0, - sub2x2+hs1-mend_minus_two_mult_hs0, hs0); - } else { - SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], - sub2x2[hs0], sub2x2[hs], - &lambda1, &lambda2, - &is_complex); - } + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); sub2x2[hs0] = zero; /// eigenvalues are from wilkinson shift @@ -189,17 +145,10 @@ namespace KokkosBatched { &lambda1, &lambda2, &is_complex); - if (request_schur) { - SerialFrancisInternal::invoke(mbeg, mend, m, - H, hs0, hs1, - lambda1, lambda2, - is_complex); - } else { - SerialFrancisInternal::invoke(0, mdiff, mdiff, - H+hs*mbeg, hs0, hs1, - lambda1, lambda2, - is_complex); - } + SerialFrancisInternal::invoke(0, mdiff, mdiff, + H+hs*mbeg, hs0, hs1, + lambda1, lambda2, + is_complex); /* */ auto &val1 = *(sub2x2+hs0); /* */ auto &val2 = *(sub2x2-hs1); const auto abs_val1 = ats::abs(val1); @@ -210,28 +159,9 @@ namespace KokkosBatched { er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; val1 = zero; } else if (abs_val2 < tol) { - er[(mend-1)*ers] = lambda1.real(); ei[(mend-1)*eis] = lambda1.imag(); - er[(mend-2)*ers] = lambda2.real(); ei[(mend-2)*eis] = lambda2.imag(); - - /// preserve the standard schur form - Kokkos::pair G; - SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, - sub2x2+hs0, sub2x2+hs, - &G, - &lambda1, &lambda2, - &is_complex); - subdiags[mend-1] = val1; + er[(mend-2)*ers] = lambda1.real(); ei[(mend-2)*eis] = lambda1.imag(); + er[(mend-1)*ers] = lambda2.real(); ei[(mend-1)*eis] = lambda2.imag(); - /// apply G' from left - G.second = -G.second; - SerialApplyLeftGivensInternal::invoke (G, m-mend, - sub2x2 +2*hs1, hs1, - sub2x2+hs0+2*hs1, hs1); - - // apply (G')' from right - SerialApplyRightGivensInternal::invoke(G, mend-2, - sub2x2 -mend_minus_two_mult_hs0, hs0, - sub2x2+hs1-mend_minus_two_mult_hs0, hs0); val1 = zero; val2 = zero; } @@ -253,13 +183,6 @@ namespace KokkosBatched { er[i*ers] = H[i*hs]; ei[i*eis] = zero; } - // recover subdiags - if (request_schur) { - real_type *Hs = H-hs1; - for (int i=1;i lambda1, const Kokkos::complex lambda2, - const bool is_complex) { + const bool is_complex, + /* */ ValueType * GG, const bool request_schur) { typedef ValueType value_type; - const int hs = hs0+hs1; + typedef Kokkos::Details::ArithTraits ats; + const int hs = hs0+hs1; const value_type zero(0); /// redefine variables const int m = mend-mbeg, mrst = morg-mend, mbeg_mult_hs0 = mbeg*hs0; - ValueType *H = HH+hs*mbeg; + value_type *H = HH+hs*mbeg; + + /// initialize Gs + value_type *Gs = NULL; + if (request_schur) { + Gs = HH+mbeg*2; + for (int i=0;i + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const Kokkos::complex lambda1, + const Kokkos::complex lambda2, + const bool is_complex) { + return invoke(mbeg, mend, morg, + HH, hs0, hs1, + lambda1, lambda2, is_complex, + (ValueType*)NULL, false); + } }; }// end namespace Experimental diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index b3816fb19d..06ca126ff5 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -22,15 +22,24 @@ namespace KokkosBatched { static int invoke(const int mbeg, const int mend, const int morg, /* */ ValueType * HH, const int hs0, const int hs1, - const ValueType shift) { + const ValueType shift, + /* */ ValueType * GG, const bool request_schur) { typedef ValueType value_type; - const int hs = hs0+hs1; + typedef Kokkos::Details::ArithTraits ats; + const int hs = hs0+hs1; const value_type zero(0); /// redefine variables const int m = mend-mbeg, mbeg_mult_hs0 = mbeg*hs0; - ValueType *H = HH+mbeg*hs; + value_type *H = HH+mbeg*hs; + + /// initialize Gs + value_type *Gs = NULL; + if (request_schur) { + Gs = GG+mbeg; + for (int i=0;i + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const ValueType shift) { + return invoke(mbeg, mend, morg, + HH, hs0, hs1, shift, + (ValueType*)NULL, false); + + } + }; + }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_UpdateGivens_Internal.hpp b/src/batched/KokkosBatched_UpdateGivens_Internal.hpp new file mode 100644 index 0000000000..5c7967bf31 --- /dev/null +++ b/src/batched/KokkosBatched_UpdateGivens_Internal.hpp @@ -0,0 +1,37 @@ +#ifndef __KOKKOSBATCHED_UPDATE_GIVENS_INTERNAL_HPP__ +#define __KOKKOSBATCHED_UPDATE_GIVENS_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialUpdateGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &S, + /* */ Kokkos::pair &G) { + const ValueType + tmp = S.first*G.first -S.second*G.second; + G.second = S.first*G.second+S.second*G.first; + G.first = tmp; + + return 0; + } + }; + + }// end namespace Experimental +} // end namespace KokkosBatched + + +#endif From 64850a20701adcd0df4a80cbb10f8939e99f5582 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 27 Nov 2018 00:27:04 -0700 Subject: [PATCH 074/190] KokkosBatched - schur decomposition with real eigenvalues --- ...HessenbergQR_WithShift_Serial_Internal.hpp | 25 +- .../KokkosBatched_Schur_Serial_Internal.hpp | 288 ++++++++++++++++++ 2 files changed, 301 insertions(+), 12 deletions(-) create mode 100644 src/batched/KokkosBatched_Schur_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index 06ca126ff5..bd1c5d1ba0 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -23,22 +23,23 @@ namespace KokkosBatched { invoke(const int mbeg, const int mend, const int morg, /* */ ValueType * HH, const int hs0, const int hs1, const ValueType shift, - /* */ ValueType * GG, const bool request_schur) { + /* */ Kokkos::pair * GG, const bool request_schur) { typedef ValueType value_type; typedef Kokkos::Details::ArithTraits ats; const int hs = hs0+hs1; - const value_type zero(0); + const value_type zero(0), one(1); + const Kokkos::pair identity(one,zero); /// redefine variables const int m = mend-mbeg, mbeg_mult_hs0 = mbeg*hs0; value_type *H = HH+mbeg*hs; /// initialize Gs - value_type *Gs = NULL; + Kokkos::pair *Gs = NULL; if (request_schur) { + for (int i=0;i*)NULL, false); } }; diff --git a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp new file mode 100644 index 0000000000..05ca8c3445 --- /dev/null +++ b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp @@ -0,0 +1,288 @@ +#ifndef __KOKKOSBATCHED_SCHUR_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_SCHUR_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_WilkinsonShift_Serial_Internal.hpp" +#include "KokkosBatched_ApplyGivens_Serial_Internal.hpp" +#include "KokkosBatched_Schur2x2_Serial_Internal.hpp" +#include "KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp" +//#include "KokkosBatched_Francis_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialSchurInternal { + /// Given a strictly Hessenberg matrix H (m x m), this computes schur decomposition + /// using the Francis method and stores them into a vector e. This routine does + /// not scale nor balance the matrix for the numerical stability. + /// H = Z T Z^H and T = Z^H H Z + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]H, [in]hs0, [in]hs1 + /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. + /// Entering the routine, H is assumed to have a upper Hessenberg form, where + /// all subdiagonals are zero. The matrix is overwritten as a upper triangular T + /// on exit. + /// [in/out]Z, [in]zs0, [in]zs1 + /// Unitary matrix resulting from Schur decomposition. With a restarting option, + /// the matrix may contain previous partial computation results. + /// [in/out]w, [in]wlen + /// Contiguous workspace of which size is wlen. When restart is true, this + /// workspace is not corrupted after the previous iteration. Temporarily, it stores + /// subdiag values and given rotations. wlen should be at least 3*m. + /// [in]restart(false) + /// With a restart option, the routine assume that the matrix H and the vector e + /// contain the partial results from the previous run. When m = 1 or 2, this option + /// won't work as the routine always computes the all eigenvalues. + /// [in]user_max_iteration(300) + /// Unlike LAPACK which uses various methods for different types of matrices, + /// this routine uses the Francis method only. A user can set the maximum number + /// of iterations. When it reaches the maximum iteration counts without converging + /// all eigenvalues, the routine returns -1. + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType * H, const int hs0, const int hs1, + /* */ RealType * Z, const int zs0, const int zs1, + /* */ RealType * w, const int wlen, + const bool restart = false, + const int user_max_iteration = -1) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); + const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; + if (wlen < m*3) + Kokkos::abort("Error: provided workspace is smaller than 3*m"); + + int r_val = 0; + if (restart) { + if (m <= 2) + Kokkos::abort("Error: restart option cannot be used for m=1 or m=2"); + } else { + SerialSetIdentityInternal::invoke(m, Z, zs0, zs1); + } + + // workspaces + real_type *subdiags = w; + Kokkos::pair *Gs = (Kokkos::pair*)(w+m); + const int nG = (wlen-m)/m/2; + printf("nG = %d\n", nG); + if (!restart) { + /// initialize workspace and Gs + for (int i=0;i lambda1, lambda2; + Kokkos::pair G; + SerialSchur2x2Internal::invoke(H, H+hs1, + H+hs0, H+hs, + &G, + &lambda1, &lambda2, + &is_complex); + + G.second = -G.second; // transpose + SerialApplyRightGivensInternal::invoke(G, 2, + Z, zs0, + Z+zs1, zs0); + break; + } + default: { + /// Francis method + int iter(0); /// iteration count + bool converge = false; /// bool to check all eigenvalues are converged + + while (!converge && iter < max_iteration) { + /// Step 1: find a set of unrevealed eigenvalues + int cnt = 1; + + /// find mbeg (first nonzero subdiag value) + for (;cnt tol) break; + } + const int mbeg = cnt-1; + + /// find mend (first zero subdiag value) + for (;cnt G(Gs[i].first, -Gs[i].second); + if (G.first == one && G.second == zero) { + // do nothing + } else { + SerialApplyRightGivensInternal::invoke(G, m, + Z+i*zs1, zs0, + Z+i*zs1+zs1, zs0); + } + } + } +# endif + +// # if 1 +// { +// /// find a complex eigen pair +// Kokkos::complex lambda1, lambda2; +// bool is_complex; +// real_type *sub2x2 = H+(mend-2)*hs; +// if (2 == mdiff) { +// if (request_schur) { +// Kokkos::pair G; +// SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, +// sub2x2+hs0, sub2x2+hs, +// &G, +// &lambda1, &lambda2, +// &is_complex); +// subdiags[mend-1] = sub2x2[hs0]; +// printf("mdiff is 2 and mend %d\n", mend); +// printf(" G %e %e\n", G.first, G.second); +// for (int q=0;q G; +// SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, +// sub2x2+hs0, sub2x2+hs, +// &G, +// &lambda1, &lambda2, +// &is_complex); +// subdiags[mend-1] = val1; +// SerialUpdateGivensInternal::invoke(G, Gs[mend-2]); + +// /// apply G' from left +// G.second = -G.second; +// SerialApplyLeftGivensInternal::invoke (G, m-mend, +// sub2x2 +2*hs1, hs1, +// sub2x2+hs0+2*hs1, hs1); + +// // apply (G')' from right +// SerialApplyRightGivensInternal::invoke(G, mend-2, +// sub2x2 -mend_minus_two_mult_hs0, hs0, +// sub2x2+hs1-mend_minus_two_mult_hs0, hs0); +// val1 = zero; +// val2 = zero; +// } +// } +// } +// # endif + } else { + /// all eigenvalues are converged + converge = true; + } + ++iter; + } + /// Step 3: record missing real eigenvalues from the diagonals + if (converge) { + // // recover subdiags + // if (request_schur) { + // real_type *Hs = H-hs1; + // for (int i=1;i Date: Tue, 27 Nov 2018 01:20:15 -0700 Subject: [PATCH 075/190] KokkosBatched - Schur decomposition completes. now we have schur decomposition. remained work is harnessing to compute right eigen vector --- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 11 +- .../KokkosBatched_Francis_Serial_Internal.hpp | 51 +++-- .../KokkosBatched_Schur_Serial_Internal.hpp | 208 ++++++++---------- 3 files changed, 128 insertions(+), 142 deletions(-) diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp index 0bd48d579b..70528f5af1 100644 --- a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -23,8 +23,9 @@ namespace KokkosBatched { const int n, /* */ ValueType * a1t, const int a1ts, /* */ ValueType * a2t, const int a2ts) { - if (n == 0) return 0; // quick return typedef ValueType value_type; + if (n == 0) return 0; // quick return + if (G.first == value_type(1) && G.second == value_type(0)) return 0; /// G = [ gamma -sigma; /// sigma gamma ]; /// A := G A @@ -53,8 +54,9 @@ namespace KokkosBatched { const int m, /* */ ValueType * a1, const int a1s, /* */ ValueType * a2, const int a2s) { - if (m == 0) return 0; // quick return typedef ValueType value_type; + if (m == 0) return 0; // quick return + if (G.first == value_type(1) && G.second == value_type(0)) return 0; /// G = [ gamma -sigma; /// sigma gamma ]; /// A := A G' @@ -86,8 +88,9 @@ namespace KokkosBatched { /* */ ValueType *__restrict__ a1, /* */ ValueType *__restrict__ a2, const int &as0, const int &as1) { - if (m == 0 && n == 0) return 0; // quick return typedef ValueType value_type; + if (G12.first == value_type(1) && G12.second == value_type(0)) return 0; + if (m == 0 && n == 0) return 0; // quick return const value_type gamma12 = G12.first; const value_type sigma12 = G12.second; @@ -127,8 +130,8 @@ namespace KokkosBatched { /* */ ValueType *__restrict__ a2, /* */ ValueType *__restrict__ a3, const int &as0, const int &as1) { - if (m == 0 && n == 0) return 0; // quick return typedef ValueType value_type; + if (m == 0 && n == 0) return 0; // quick return const value_type gamma12 = G12.first; const value_type sigma12 = G12.second; diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp index 7b5399bee4..b1e55a543e 100644 --- a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -1,5 +1,5 @@ #ifndef __KOKKOSBATCHED_FRANCIS_SERIAL_INTERNAL_HPP__ -#define __KOKKOSBATCHED_FRAMCIS_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_FRANCIS_SERIAL_INTERNAL_HPP__ /// \author Kyungjoo Kim (kyukim@sandia.gov) @@ -25,24 +25,24 @@ namespace KokkosBatched { const Kokkos::complex lambda1, const Kokkos::complex lambda2, const bool is_complex, - /* */ ValueType * GG, const bool request_schur) { + /* */ Kokkos::pair * GG, const bool request_schur) { typedef ValueType value_type; - typedef Kokkos::Details::ArithTraits ats; - + const int hs = hs0+hs1; - const value_type zero(0); + const value_type one(1), zero(0); + const Kokkos::pair identity(one,zero); /// redefine variables const int m = mend-mbeg, mrst = morg-mend, mbeg_mult_hs0 = mbeg*hs0; value_type *H = HH+hs*mbeg; /// initialize Gs - value_type *Gs = NULL; + Kokkos::pair *Gs = NULL; if (request_schur) { - Gs = HH+mbeg*2; + Gs = (Kokkos::pair *)(GG+mbeg*2); for (int i=0;i*)NULL, false); } }; diff --git a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp index 05ca8c3445..040aadf909 100644 --- a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp @@ -61,7 +61,7 @@ namespace KokkosBatched { typedef Kokkos::Details::ArithTraits ats; const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; - if (wlen < m*3) + if (wlen < m*5) Kokkos::abort("Error: provided workspace is smaller than 3*m"); int r_val = 0; @@ -75,8 +75,6 @@ namespace KokkosBatched { // workspaces real_type *subdiags = w; Kokkos::pair *Gs = (Kokkos::pair*)(w+m); - const int nG = (wlen-m)/m/2; - printf("nG = %d\n", nG); if (!restart) { /// initialize workspace and Gs for (int i=0;i G(Gs[i].first, -Gs[i].second); - if (G.first == one && G.second == zero) { - // do nothing - } else { - SerialApplyRightGivensInternal::invoke(G, m, - Z+i*zs1, zs0, - Z+i*zs1+zs1, zs0); - } + SerialApplyRightGivensInternal::invoke(G, m, + Z+i*zs1, zs0, + Z+i*zs1+zs1, zs0); } } # endif -// # if 1 -// { -// /// find a complex eigen pair -// Kokkos::complex lambda1, lambda2; -// bool is_complex; -// real_type *sub2x2 = H+(mend-2)*hs; -// if (2 == mdiff) { -// if (request_schur) { -// Kokkos::pair G; -// SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, -// sub2x2+hs0, sub2x2+hs, -// &G, -// &lambda1, &lambda2, -// &is_complex); -// subdiags[mend-1] = sub2x2[hs0]; -// printf("mdiff is 2 and mend %d\n", mend); -// printf(" G %e %e\n", G.first, G.second); -// for (int q=0;q lambda1, lambda2; + bool is_complex; + real_type *sub2x2 = H+(mend-2)*hs; + if (2 == mdiff) { + Kokkos::pair G; + SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, + sub2x2+hs0, sub2x2+hs, + &G, + &lambda1, &lambda2, + &is_complex); + subdiags[mend-1] = sub2x2[hs0]; -// /// apply G' from left -// G.second = -G.second; -// SerialApplyLeftGivensInternal::invoke (G, m-mend, -// sub2x2 +2*hs1, hs1, -// sub2x2+hs0+2*hs1, hs1); + /// apply G' from left + G.second = -G.second; + SerialApplyLeftGivensInternal::invoke (G, m-mend, + sub2x2 +2*hs1, hs1, + sub2x2+hs0+2*hs1, hs1); -// /// apply (G')' from right -// SerialApplyRightGivensInternal::invoke(G, mend-2, -// sub2x2 -mend_minus_two_mult_hs0, hs0, -// sub2x2+hs1-mend_minus_two_mult_hs0, hs0); -// } else { -// SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], -// sub2x2[hs0], sub2x2[hs], -// &lambda1, &lambda2, -// &is_complex); -// } -// sub2x2[hs0] = zero; + /// apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, mend-2, + sub2x2 -mend_minus_two_mult_hs0, hs0, + sub2x2+hs1-mend_minus_two_mult_hs0, hs0); + sub2x2[hs0] = zero; -// /// eigenvalues are from wilkinson shift -// er[(mbeg+0)*ers] = lambda1.real(); ei[(mbeg+0)*eis] = lambda1.imag(); -// er[(mbeg+1)*ers] = lambda2.real(); ei[(mbeg+1)*eis] = lambda2.imag(); -// } else { -// SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], -// sub2x2[hs0], sub2x2[hs], -// &lambda1, &lambda2, -// &is_complex); + /// apply (G')' from right to compute Z + SerialApplyRightGivensInternal::invoke(G, m, + Z+(mend-2)*zs1, zs0, + Z+(mend-1)*zs1, zs0); -// SerialFrancisInternal::invoke(request_schur ? mbeg : 0, -// request_schur ? mend : mdiff, -// request_schur ? m : mdiff, -// request_schur ? H : (H+hs*mbeg), -// hs0, hs1, -// Gs, request_schur, -// lambda1, lambda2, -// is_complex); -// /* */ auto &val1 = *(sub2x2+hs0); -// /* */ auto &val2 = *(sub2x2-hs1); -// const auto abs_val1 = ats::abs(val1); -// const auto abs_val2 = ats::abs(val2); - -// /// convergence check -// if (abs_val1 < tol) { -// er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; -// val1 = zero; -// } else if (abs_val2 < tol) { -// printf("this should not be called\n"); -// er[(mend-1)*ers] = lambda1.real(); ei[(mend-1)*eis] = lambda1.imag(); -// er[(mend-2)*ers] = lambda2.real(); ei[(mend-2)*eis] = lambda2.imag(); + } else { + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); + + SerialFrancisInternal::invoke(mbeg, mend, m, + H, hs0, hs1, + lambda1, lambda2, + is_complex, + Gs, true); + /* */ auto &val1 = *(sub2x2+hs0); + /* */ auto &val2 = *(sub2x2-hs1); + const auto abs_val1 = ats::abs(val1); + const auto abs_val2 = ats::abs(val2); -// /// preserve the standard schur form -// Kokkos::pair G; -// SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, -// sub2x2+hs0, sub2x2+hs, -// &G, -// &lambda1, &lambda2, -// &is_complex); -// subdiags[mend-1] = val1; -// SerialUpdateGivensInternal::invoke(G, Gs[mend-2]); + for (int i=mbeg;i<(mend-1);++i) { + const Kokkos::pair G0(Gs[2*i ].first, -Gs[2*i ].second); + const Kokkos::pair G1(Gs[2*i+1].first, -Gs[2*i+1].second); + SerialApplyRightGivensInternal::invoke(G0, m, + Z+i*zs1, zs0, + Z+i*zs1+1*zs1, zs0); + SerialApplyRightGivensInternal::invoke(G1, m, + Z+i*zs1, zs0, + Z+i*zs1+2*zs1, zs0); + } + + /// convergence check + if (abs_val1 < tol) { + val1 = zero; + } else if (abs_val2 < tol) { + /// preserve the standard schur form + Kokkos::pair G; + SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, + sub2x2+hs0, sub2x2+hs, + &G, + &lambda1, &lambda2, + &is_complex); + subdiags[mend-1] = val1; -// /// apply G' from left -// G.second = -G.second; -// SerialApplyLeftGivensInternal::invoke (G, m-mend, -// sub2x2 +2*hs1, hs1, -// sub2x2+hs0+2*hs1, hs1); + /// apply G' from left + G.second = -G.second; + SerialApplyLeftGivensInternal::invoke (G, m-mend, + sub2x2 +2*hs1, hs1, + sub2x2+hs0+2*hs1, hs1); + + // apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, mend-2, + sub2x2 -mend_minus_two_mult_hs0, hs0, + sub2x2+hs1-mend_minus_two_mult_hs0, hs0); + val1 = zero; + val2 = zero; -// // apply (G')' from right -// SerialApplyRightGivensInternal::invoke(G, mend-2, -// sub2x2 -mend_minus_two_mult_hs0, hs0, -// sub2x2+hs1-mend_minus_two_mult_hs0, hs0); -// val1 = zero; -// val2 = zero; -// } -// } -// } -// # endif + // apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, m, + Z+(mend-2)*zs1, zs0, + Z+(mend-1)*zs1, zs0); + } + } + } +# endif } else { /// all eigenvalues are converged converge = true; @@ -262,13 +248,11 @@ namespace KokkosBatched { } /// Step 3: record missing real eigenvalues from the diagonals if (converge) { - // // recover subdiags - // if (request_schur) { - // real_type *Hs = H-hs1; - // for (int i=1;i Date: Wed, 28 Nov 2018 14:16:45 -0700 Subject: [PATCH 076/190] KokkosBatched - left and right eigenvalues are computed I still need to handle 2x2 forward and backward substitutions --- ...hed_Eigendecomposition_Serial_Internal.hpp | 279 ++++++++++++++++++ ...ftEigenvectorFromSchur_Serial_Internal.hpp | 136 +++++++++ .../KokkosBatched_Normalize_Internal.hpp | 31 ++ ...htEigenvectorFromSchur_Serial_Internal.hpp | 131 ++++---- .../KokkosBatched_Schur_Serial_Internal.hpp | 5 +- src/batched/KokkosBatched_Util.hpp | 1 + 6 files changed, 527 insertions(+), 56 deletions(-) create mode 100644 src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp create mode 100644 src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp new file mode 100644 index 0000000000..2ac3d066da --- /dev/null +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -0,0 +1,279 @@ +#ifndef __KOKKOSBATCHED_EIGENDECOMPOSITION_SERIAL_INTERNAL_HPP__ +#define __KOKKOSBATCHED_EIGENDECOMPOSITION_SERIAL_INTERNAL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_SetIdentity_Internal.hpp" +#include "KokkosBatched_SetTriangular_Internal.hpp" +#include "KokkosBatched_Normalize_Internal.hpp" +#include "KokkosBatched_Hessenberg_Serial_Internal.hpp" +#include "KokkosBatched_ApplyQ_Serial_Internal.hpp" +#include "KokkosBatched_Schur_Serial_Internal.hpp" +#include "KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp" +#include "KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp" +#include "KokkosBatched_Gemm_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialEigendecompositionInternal { + /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition + /// of the matrix. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]A, [in]as0, [in]as1 + /// Real general nonsymmetric matrix A(m x m) with strides as0 and as1. + /// A is first condensed to a upper Hessenberg form. Then, the Francis + /// double shift QR algorithm is applied to compute its Schur form. + /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. + /// [out]er, [in]ers, [out]ei, [in]eis + /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [out]UL, [in]uls0, [in] uls1 + /// Left eigenvectors UL(m x m) with strides uls0 and uls1. When UL is NULL, the left + /// eigenvectors are not computed. + /// [out]UR, [in]urs0, [in] urs1 + /// Right eigenvectors UR(m x m) with strides urs0 and urs1. When UR is NULL, the right + /// eigenvectors are not computed. + /// [out]w, [in]wlen + /// Workspace + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + RealType * A, const int as0, const int as1, + RealType * er, const int ers, + RealType * ei, const int eis, + RealType * UL, const int uls0, const int uls1, + RealType * UR, const int urs0, const int urs1, + RealType * w, const int wlen) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + + const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); + const Kokkos::pair identity(one, zero); + + /// step 0: input checking + real_type *w_now = w; + int wlen_now = wlen; + assert( (wlen_now >= 0) && "Eigendecomposition: workspace size is negative"); + + const bool is_UL = UL != NULL, is_UR = UR != NULL; + const bool is_U = is_UL || is_UR; + assert( is_U && "Eigendecomposition: eigenvectors are not requested; consider to use SerialEigenvalueInternal"); + + real_type *QZ = w_now; w_now += (m*m); wlen_now -= (m*m); + assert( (wlen_now >= 0) && "Eigendecomposition: QZ allocation fails"); + + const int qzs0 = m, qzs1 = 1, qzs = m+1; /// row major + const int as = as0+as1; + + /// step 1: Hessenberg reduction A = Q H Q^H + /// Q is stored in UL if requested. + { + real_type *t = w_now; w_now += m; wlen_now -= m; + real_type *ww = w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t and ww allocation fail"); + + SerialHessenbergInternal::invoke(m, m, + A, as0, as1, + t, 1, + ww); + + SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); + SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m, m-1, + A+as, as0, as1, + t, 1, + QZ+qzs, qzs0, qzs1, + ww); + + /// clean up H + SerialSetLowerTriangularInternal::invoke(m, m, + 2, + zero, + A, as0, as1); + + /// recover workspace + w_now -= (2*m); wlen_now += (2*m); + } + + /// step 2: Schur decomposition H = Z T Z^H + /// Z is applied to UL if requested + { + int r_val = 0; + real_type *ww = w_now; w_now += (5*m); wlen_now -= (5*m); + assert( (wlen_now >= 0) && "Eigendecomposition: Schur decomposition workspace ww allocation fails"); + do { + const bool restart = (r_val < 0); + r_val = SerialSchurInternal::invoke(m, + A, as0, as1, + QZ, qzs0, qzs1, + ww, 5*m, + restart); + } while (r_val < 0 && false); + // for a testing purpose, we run the Schur decomposition with a finite number of Francis iterations + w_now -= (5*m); wlen_now += (5*m); + + printf("QZ = \n"); + for (int i=0;i= 0) && "Eigendecomposition: Eigenvector workspace V allocation fails"); + + const int vs0 = 1, vs1 = m; + real_type *ww = w_now; w_now += 2*m; wlen_now -= 2*m; + assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace w allocation fails"); + + /// Right eigenvectors V stores V^-1 + if (is_UR) { + SerialRightEigenvectorFromSchurInternal + ::invoke(m, + A, as0, as1, + V, vs0, vs1, + ww); + + printf("Right V = \n"); + for (int i=0;i:: + invoke(m, m, m, + one, + V, vs0, vs1, + QZ, qzs1, qzs0, + zero, + UR, urs0, urs1); + int j=0; + for (;j:: + invoke(m, m, m, + one, + QZ, qzs0, qzs1, + V, vs0, vs1, + zero, + UL, uls0, uls1); + + int i=0; + for (;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * S, const int ss0, const int ss1, + /* */ ValueType * V, const int vs0, const int vs1, + /* */ ValueType * w) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; + typedef Kokkos::complex complex_type; + + const value_type zero(0), one(1); + const int ss(ss0+ss1); + + /// partitions used for loop iteration + Partition2x2 S_part2x2(ss0, ss1); + Partition3x3 S_part3x3(ss0, ss1); + + Partition1x2 V_part1x2(vs1); + Partition1x3 V_part1x3(vs1); + + /// initial partition of S where ABR has a zero dimension + S_part2x2.partWithABR(S, m, m, 0, 0); + V_part1x2.partWithAR(V, m, 0); + + const mag_type tol = ats::epsilon(); + int m_stl = m; + for (;m_stl>0;) { + const value_type subdiag = ats::abs(*(S_part2x2.ABR-ss-ss1)); + + /// part 2x2 into 3x3 + const bool subdiag_is_zero = subdiag < tol; + const int mA11 = subdiag_is_zero ? 1 : 2; + S_part3x3.partWithATL(S_part2x2, mA11, mA11); + V_part1x3.partWithAL(V_part1x2, mA11); + + const int m_stl_minus_mA11 = m_stl - mA11; + if (subdiag_is_zero) { + /// real eigenvalue + const value_type lambda = *S_part3x3.A11; + + /// initialize a left eigen vector + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType *__restrict__ vr, const int vrs, + /* */ RealType *__restrict__ vi, const int vis) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; + + mag_type norm(0); +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int i=0;i::sqrt(norm); +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int i=0;i complex_type; const value_type zero(0), one(1); - + SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); + + value_type *b = w; // consider complex case + /// partitions used for loop iteration Partition2x2 S_part2x2(ss0, ss1); Partition3x3 S_part3x3(ss0, ss1); - Partition1x2 V_part1x2(vs1); - Partition1x3 V_part1x3(vs1); + Partition2x1 V_part2x1(vs0); + Partition3x1 V_part3x1(vs0); - /// initial partition of S where ABR has a zero dimension - S_part2x2.partWithABR(S, m, m, 0, 0); - V_part1x2.partWithAR(V, m, 0); + /// initial partition of S where ATL has a zero dimension + S_part2x2.partWithATL(S, m, m, 0, 0); + V_part2x1.partWithAT(V, m, 0); const mag_type tol = ats::epsilon(); - int m_stl = m; - for (;m_stl>0;) { - const value_type subdiag = ats::abs(*(S_part2x2.ABR-ss0-2*ss1)); + int m_stl = 0; + for (;m_stl<(m-1);) { + const value_type subdiag = ats::abs(*(S_part2x2.ABR+ss0)); /// part 2x2 into 3x3 const bool subdiag_is_zero = subdiag < tol; const int mA11 = subdiag_is_zero ? 1 : 2; - S_part3x3.partWithATL(S_part2x2, mA11, mA11); - V_part1x3.partWithAL(V_part1x2, mA11); + S_part3x3.partWithABR(S_part2x2, mA11, mA11); + V_part3x1.partWithAB(V_part2x1, mA11); + const int m_stl_plus_mA11 = m_stl+mA11; if (subdiag_is_zero) { + /// real eigenvalue const value_type lambda = *S_part3x3.A11; + + /// initialize a right hand side + b[m_stl] = one; + printf("rhs = \n"); + for (int j=0;j<(m-m_stl_plus_mA11);++j) { + b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; + printf(" %e \n", b[j+m_stl_plus_mA11]); + } + /// perform shifted trsv (transposed) + SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, + S_part3x3.A22, ss1, ss0, + w+m_stl_plus_mA11, 1); + + printf("sol = \n"); + for (int j=0;j<(m-m_stl_plus_mA11);++j) { + printf(" %e \n", b[j+m_stl_plus_mA11]); + } + + /// copy back to V (row wise copy) + for (int j=0;j #include +#include #include #include #include From d38d5ab69139dcf008baea0e9fe7f01b50b7ea82 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 28 Nov 2018 17:43:07 -0700 Subject: [PATCH 077/190] KokkosBatched - left right eigenvectors are computed --- ...hed_Eigendecomposition_Serial_Internal.hpp | 15 ++- ...ftEigenvectorFromSchur_Serial_Internal.hpp | 37 +++--- ...htEigenvectorFromSchur_Serial_Internal.hpp | 64 +++------ ...kosBatched_ShiftedTrsv_Serial_Internal.hpp | 125 +++++++++++++----- 4 files changed, 151 insertions(+), 90 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index 2ac3d066da..cc859d1795 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -137,6 +137,9 @@ namespace KokkosBatched { { /// extract eigenvalues real_type *AA = A-as1; + int *blks = (int*)w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace blks allocation fails"); + { int i=0; for (;i<(m-1);) { @@ -145,6 +148,7 @@ namespace KokkosBatched { if (subdiag < tol) { er[i*ers] = diag; ei[i*eis] = zero; + blks[i] = 1; i+=1; } else { const real_type offdiag = ats::abs(A[i*as+as1]); @@ -153,12 +157,15 @@ namespace KokkosBatched { er[(i+1)*ers] = diag; ei[(i )*eis] = sqrt_mult_suboffdiags; ei[(i+1)*eis] = -sqrt_mult_suboffdiags; + blks[i ] = 2; + blks[i+1] = 2; /// consider backward iteration i+=2; } } if (i ats; typedef typename ats::mag_type mag_type; @@ -43,6 +44,9 @@ namespace KokkosBatched { const value_type zero(0), one(1); const int ss(ss0+ss1); + /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); + + value_type *b = w; // consider complex case /// partitions used for loop iteration Partition2x2 S_part2x2(ss0, ss1); @@ -58,28 +62,28 @@ namespace KokkosBatched { const mag_type tol = ats::epsilon(); int m_stl = m; for (;m_stl>0;) { - const value_type subdiag = ats::abs(*(S_part2x2.ABR-ss-ss1)); - /// part 2x2 into 3x3 - const bool subdiag_is_zero = subdiag < tol; - const int mA11 = subdiag_is_zero ? 1 : 2; + const int mA11 = blks[m_stl-1]; + assert( ((mA11 == 1) || (mA11 == 2)) && "LeftEigenvectorFromSchur: blk is not 1x1 nor 2x2"); + S_part3x3.partWithATL(S_part2x2, mA11, mA11); V_part1x3.partWithAL(V_part1x2, mA11); const int m_stl_minus_mA11 = m_stl - mA11; - if (subdiag_is_zero) { + if (mA11 == 1) { /// real eigenvalue const value_type lambda = *S_part3x3.A11; /// initialize a left eigen vector for (int i=0;i ats; typedef typename ats::mag_type mag_type; typedef Kokkos::complex complex_type; const value_type zero(0), one(1); - SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); + /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); value_type *b = w; // consider complex case @@ -60,48 +61,32 @@ namespace KokkosBatched { const mag_type tol = ats::epsilon(); int m_stl = 0; for (;m_stl<(m-1);) { - const value_type subdiag = ats::abs(*(S_part2x2.ABR+ss0)); - /// part 2x2 into 3x3 - const bool subdiag_is_zero = subdiag < tol; - const int mA11 = subdiag_is_zero ? 1 : 2; + const int mA11 = blks[m_stl]; + assert( ((mA11 == 1) || (mA11 == 2)) && "RightEigenvectorFromSchur: blk is not 1x1 nor 2x2"); + S_part3x3.partWithABR(S_part2x2, mA11, mA11); V_part3x1.partWithAB(V_part2x1, mA11); const int m_stl_plus_mA11 = m_stl+mA11; - if (subdiag_is_zero) { - + if (mA11 == 1) { /// real eigenvalue const value_type lambda = *S_part3x3.A11; /// initialize a right hand side b[m_stl] = one; - printf("rhs = \n"); - for (int j=0;j<(m-m_stl_plus_mA11);++j) { + for (int j=0;j<(m-m_stl_plus_mA11);++j) b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; - printf(" %e \n", b[j+m_stl_plus_mA11]); - } + /// perform shifted trsv (transposed) SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, S_part3x3.A22, ss1, ss0, - w+m_stl_plus_mA11, 1); - - printf("sol = \n"); - for (int j=0;j<(m-m_stl_plus_mA11);++j) { - printf(" %e \n", b[j+m_stl_plus_mA11]); - } - + b+m_stl_plus_mA11, 1, + blks+m_stl_plus_mA11); + /// copy back to V (row wise copy) for (int j=0;j=0;--p) { - const int iend = p; - - const ValueTypeA *__restrict__ a01 = A+p*as1; - /**/ ValueTypeB *__restrict__ beta1 = b+p*bs0; - - // with __restrict__ a compiler assumes that the pointer is not accessed by others - // op(/=) uses this pointer and changes the associated values, which brings a compiler problem - *beta1 = *beta1 / (A[p*as0+p*as1] - lambda); - - for (int i=0;i=0;) { + const int blk = blks[p], iend = p+1-blk; + assert( ((blk == 1) || (blk == 2)) && "ShiftedTrsvUpper: blocks are not 1x1 or 2x2"); + if (blk == 1) { + const auto alpha11 = A[p*as]-lambda; + /**/ ValueTypeB *__restrict__ beta1 = b+p*bs0; + + // with __restrict__ a compiler assumes that the pointer is not accessed by others + // op(/=) uses this pointer and changes the associated values, which brings a compiler problem + *beta1 = *beta1 / alpha11; + + if (iend) { + const ValueTypeA *__restrict__ a01 = A+p*as1; + for (int i=0;i Date: Wed, 28 Nov 2018 17:47:17 -0700 Subject: [PATCH 078/190] KokkosBatched - I confused the definition of left and right eigenvectors I swapped implementations --- ...ftEigenvectorFromSchur_Serial_Internal.hpp | 106 ++++++++++-------- ...htEigenvectorFromSchur_Serial_Internal.hpp | 106 ++++++++---------- 2 files changed, 106 insertions(+), 106 deletions(-) diff --git a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp index 6fc8c5965f..d0372d6834 100644 --- a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp @@ -43,7 +43,6 @@ namespace KokkosBatched { typedef Kokkos::complex complex_type; const value_type zero(0), one(1); - const int ss(ss0+ss1); /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); value_type *b = w; // consider complex case @@ -52,42 +51,42 @@ namespace KokkosBatched { Partition2x2 S_part2x2(ss0, ss1); Partition3x3 S_part3x3(ss0, ss1); - Partition1x2 V_part1x2(vs1); - Partition1x3 V_part1x3(vs1); + Partition2x1 V_part2x1(vs0); + Partition3x1 V_part3x1(vs0); - /// initial partition of S where ABR has a zero dimension - S_part2x2.partWithABR(S, m, m, 0, 0); - V_part1x2.partWithAR(V, m, 0); + /// initial partition of S where ATL has a zero dimension + S_part2x2.partWithATL(S, m, m, 0, 0); + V_part2x1.partWithAT(V, m, 0); const mag_type tol = ats::epsilon(); - int m_stl = m; - for (;m_stl>0;) { + int m_stl = 0; + for (;m_stl<(m-1);) { /// part 2x2 into 3x3 - const int mA11 = blks[m_stl-1]; + const int mA11 = blks[m_stl]; assert( ((mA11 == 1) || (mA11 == 2)) && "LeftEigenvectorFromSchur: blk is not 1x1 nor 2x2"); - S_part3x3.partWithATL(S_part2x2, mA11, mA11); - V_part1x3.partWithAL(V_part1x2, mA11); + S_part3x3.partWithABR(S_part2x2, mA11, mA11); + V_part3x1.partWithAB(V_part2x1, mA11); - const int m_stl_minus_mA11 = m_stl - mA11; + const int m_stl_plus_mA11 = m_stl+mA11; if (mA11 == 1) { /// real eigenvalue const value_type lambda = *S_part3x3.A11; + + /// initialize a left hand side + b[m_stl] = one; + for (int j=0;j<(m-m_stl_plus_mA11);++j) + b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; + + /// perform shifted trsv (transposed) + SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, + S_part3x3.A22, ss1, ss0, + b+m_stl_plus_mA11, 1, + blks+m_stl_plus_mA11); - /// initialize a left eigen vector - for (int i=0;i complex_type; const value_type zero(0), one(1); + const int ss(ss0+ss1); /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); value_type *b = w; // consider complex case @@ -51,42 +52,42 @@ namespace KokkosBatched { Partition2x2 S_part2x2(ss0, ss1); Partition3x3 S_part3x3(ss0, ss1); - Partition2x1 V_part2x1(vs0); - Partition3x1 V_part3x1(vs0); + Partition1x2 V_part1x2(vs1); + Partition1x3 V_part1x3(vs1); - /// initial partition of S where ATL has a zero dimension - S_part2x2.partWithATL(S, m, m, 0, 0); - V_part2x1.partWithAT(V, m, 0); + /// initial partition of S where ABR has a zero dimension + S_part2x2.partWithABR(S, m, m, 0, 0); + V_part1x2.partWithAR(V, m, 0); const mag_type tol = ats::epsilon(); - int m_stl = 0; - for (;m_stl<(m-1);) { + int m_stl = m; + for (;m_stl>0;) { /// part 2x2 into 3x3 - const int mA11 = blks[m_stl]; + const int mA11 = blks[m_stl-1]; assert( ((mA11 == 1) || (mA11 == 2)) && "RightEigenvectorFromSchur: blk is not 1x1 nor 2x2"); - S_part3x3.partWithABR(S_part2x2, mA11, mA11); - V_part3x1.partWithAB(V_part2x1, mA11); + S_part3x3.partWithATL(S_part2x2, mA11, mA11); + V_part1x3.partWithAL(V_part1x2, mA11); - const int m_stl_plus_mA11 = m_stl+mA11; + const int m_stl_minus_mA11 = m_stl - mA11; if (mA11 == 1) { /// real eigenvalue const value_type lambda = *S_part3x3.A11; - - /// initialize a right hand side - b[m_stl] = one; - for (int j=0;j<(m-m_stl_plus_mA11);++j) - b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; - - /// perform shifted trsv (transposed) - SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, - S_part3x3.A22, ss1, ss0, - b+m_stl_plus_mA11, 1, - blks+m_stl_plus_mA11); - /// copy back to V (row wise copy) - for (int j=0;j Date: Wed, 28 Nov 2018 22:40:51 -0700 Subject: [PATCH 079/190] KokkosBatched - eigenvectors are finally computed --- ...hed_Eigendecomposition_Serial_Internal.hpp | 66 +++++-------------- 1 file changed, 18 insertions(+), 48 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index cc859d1795..05f54b5aba 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -90,12 +90,12 @@ namespace KokkosBatched { ww); SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); - SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m, m-1, - A+as, as0, as1, + SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m-1, m-1, + A+as0, as0, as1, t, 1, QZ+qzs, qzs0, qzs1, ww); - + /// clean up H SerialSetLowerTriangularInternal::invoke(m, m, 2, @@ -121,19 +121,11 @@ namespace KokkosBatched { restart); } while (r_val < 0 && false); // for a testing purpose, we run the Schur decomposition with a finite number of Francis iterations - w_now -= (5*m); wlen_now += (5*m); - - printf("QZ = \n"); - for (int i=0;i= 0) && "Eigendecomposition: Eigenvector workspace w allocation fails"); - /// Right eigenvectors V stores V^-1 + /// Right eigenvectors V if (is_UR) { SerialRightEigenvectorFromSchurInternal ::invoke(m, @@ -186,19 +178,12 @@ namespace KokkosBatched { ww, blks); - printf("Right V = \n"); - for (int i=0;i:: invoke(m, m, m, one, + QZ, qzs0, qzs1, V, vs0, vs1, - QZ, qzs1, qzs0, zero, UR, urs0, urs1); int j=0; @@ -216,13 +201,6 @@ namespace KokkosBatched { j+=2; } } - - printf("UR = V*(QZ)^H = \n"); - for (int i=0;i:: invoke(m, m, m, one, - QZ, qzs0, qzs1, V, vs0, vs1, + QZ, qzs1, qzs0, zero, UL, uls0, uls1); int i=0; for (;i Date: Wed, 28 Nov 2018 23:57:51 -0700 Subject: [PATCH 080/190] KokkosBatched - add an assert to check workspace size --- src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index 05f54b5aba..9cca5ccc7a 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -63,6 +63,7 @@ namespace KokkosBatched { const Kokkos::pair identity(one, zero); /// step 0: input checking + assert( (wlen >= (2*m*m+5*m)) && "Eigendecomposition: workspace size is too small"); real_type *w_now = w; int wlen_now = wlen; assert( (wlen_now >= 0) && "Eigendecomposition: workspace size is negative"); From e1c3ddfb855fe6823e6dd8ed7591f48125da114d Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 11 Dec 2018 16:13:09 -0700 Subject: [PATCH 081/190] KokkosBatched -eigen solver --- .../KokkosBatched_Eigendecomposition_Decl.hpp | 61 +++++++++++++++++++ ...Batched_Eigendecomposition_Serial_Impl.hpp | 57 +++++++++++++++++ ...hed_Eigendecomposition_Serial_Internal.hpp | 8 +-- ...osBatched_Eigendecomposition_Team_Impl.hpp | 60 ++++++++++++++++++ 4 files changed, 181 insertions(+), 5 deletions(-) create mode 100644 src/batched/KokkosBatched_Eigendecomposition_Decl.hpp create mode 100644 src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp create mode 100644 src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp diff --git a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp new file mode 100644 index 0000000000..c139462bf5 --- /dev/null +++ b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp @@ -0,0 +1,61 @@ +#ifndef __KOKKOSBATCHED_EIGENDECOMPOSITION_DECL_HPP__ +#define __KOKKOSBATCHED_EIGENDECOMPOSITION_DECL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +namespace KokkosBatched { + namespace Experimental { + /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition + /// of the matrix. + /// + /// Parameters: + /// [in] member + /// Team interface only has this argument. Partial specialization can be applied for + /// a different type of team member. + /// [in/out]A + /// Real general nonsymmetric rank 2 view A(m x m). + /// A is first condensed to a upper Hessenberg form. Then, the Francis + /// double shift QR algorithm is applied to compute its Schur form. + /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. + /// [out]er, [out]ei + /// A real and imaginary eigenvalues, which forms er(m)+ei(m)i + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [out]UL, [out]UR + /// Left/right eigenvectors are stored in (m x m) matrices. If zero span view is provided, + /// it does not compute the corresponding eigenvectors. However, both UL and UR cannot have + /// zero span. If eigenvalues are only requested, use the Eigenvalue interface which + /// simplifies computations + /// [out]W + /// 1D contiguous workspace. The minimum size is (2*m*m+5*m) where m is the dimension of matrix A. + + struct SerialEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W); + }; + + template + struct TeamEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W); + }; + + + }/// end namespace Experimental +} /// end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp new file mode 100644 index 0000000000..1f4b98df30 --- /dev/null +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp @@ -0,0 +1,57 @@ +#ifndef __KOKKOSBATCHED_EIGENDECOMPOSITION_SERIAL_IMPL_HPP__ +#define __KOKKOSBATCHED_EIGENDECOMPOSITION_SERIAL_IMPL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Eigendecomposition_Serial_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Impl + /// =========== + + struct SerialEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W) { + /// view checking + const int m = A.extent(0); + assert(m == A.extent(1) && "Eigendecomposition: A is not square"); + assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); + + /// static assert A,er,ei,UL,UR,W has the same value_type + /// static assert all views have the same memory space + return SerialEigendecompositionInternal + ::invoke(A.extent(0), + A.data(), A.stride(0), A.stride(1), + er.data(), er.stride(0), + ei.data(), ei.stride(0), + UL.data(), UL.stride(0), UL.stride(1), + UR.data(), UR.stride(0), UR.stride(1), + W.data(), W.extent(0)); + } + }; + + + }/// end namespace Experimental +} /// end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index 9cca5ccc7a..c9a93654ce 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -20,9 +20,7 @@ namespace KokkosBatched { /// /// Serial Internal Impl /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// + struct SerialEigendecompositionInternal { /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition /// of the matrix. @@ -79,7 +77,7 @@ namespace KokkosBatched { const int as = as0+as1; /// step 1: Hessenberg reduction A = Q H Q^H - /// Q is stored in UL if requested. + /// Q is stored in QZ { real_type *t = w_now; w_now += m; wlen_now -= m; real_type *ww = w_now; w_now += m; wlen_now -= m; @@ -108,7 +106,7 @@ namespace KokkosBatched { } /// step 2: Schur decomposition H = Z T Z^H - /// Z is applied to UL if requested + /// Z is applied to QZ { int r_val = 0; real_type *ww = w_now; w_now += (5*m); wlen_now -= (5*m); diff --git a/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp new file mode 100644 index 0000000000..6ae1752e21 --- /dev/null +++ b/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp @@ -0,0 +1,60 @@ +#ifndef __KOKKOSBATCHED_EIGENDECOMPOSITION_TEAM_IMPL_HPP__ +#define __KOKKOSBATCHED_EIGENDECOMPOSITION_TEAM_IMPL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Eigendecomposition_Team_Internal.hpp" + +namespace KokkosBatched { + namespace Experimental { + /// + /// Team Impl + /// ========= + + template + struct TeamEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W) { + /// view checking + const int m = A.extent(0); + assert(m == A.extent(1) && "Eigendecomposition: A is not square"); + assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); + + /// static assert A,er,ei,UL,UR,W has the same value_type + /// static assert all views have the same memory space + return TeamEigendecompositionInternal + ::invoke(member, + A.extent(0), + A.data(), A.stride(0), A.stride(1), + er.data(), er.stride(0), + ei.data(), ei.stride(0), + UL.data(), UL.stride(0), UL.stride(1), + UR.data(), UR.stride(0), UR.stride(1), + W.data(), W.extent(0)); + } + }; + + + }/// end namespace Experimental +} /// end namespace KokkosBatched + + +#endif From 9a5412812af0699b9f630b9334f94edc035fc58d Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 17 Dec 2018 15:30:08 -0700 Subject: [PATCH 082/190] KokkosBatched - fix for impl interface --- .../KokkosBatched_Eigendecomposition_Decl.hpp | 8 ++- ...Batched_Eigendecomposition_Serial_Impl.hpp | 70 +++++++++---------- ...hed_Eigendecomposition_Serial_Internal.hpp | 41 ++++++++++- 3 files changed, 80 insertions(+), 39 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp index c139462bf5..71742047f3 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp @@ -30,7 +30,10 @@ namespace KokkosBatched { /// 1D contiguous workspace. The minimum size is (2*m*m+5*m) where m is the dimension of matrix A. struct SerialEigendecomposition { - template + template KOKKOS_INLINE_FUNCTION static int invoke(const AViewType &A, @@ -43,7 +46,8 @@ namespace KokkosBatched { struct TeamEigendecomposition { template + typename UViewType, + typename WViewType> KOKKOS_INLINE_FUNCTION static int invoke(const MemberType &member, diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp index 1f4b98df30..4575aa5f41 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp @@ -13,42 +13,40 @@ namespace KokkosBatched { /// Serial Impl /// =========== - struct SerialEigendecomposition { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - const EViewType &er, const EViewType &ei, - const UViewType &UL, const UViewType &UR, - const WViewType &W) { - /// view checking - const int m = A.extent(0); - assert(m == A.extent(1) && "Eigendecomposition: A is not square"); - assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); - assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); - assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); - assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); - assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); - assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); - assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); - assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); - - /// static assert A,er,ei,UL,UR,W has the same value_type - /// static assert all views have the same memory space - return SerialEigendecompositionInternal - ::invoke(A.extent(0), - A.data(), A.stride(0), A.stride(1), - er.data(), er.stride(0), - ei.data(), ei.stride(0), - UL.data(), UL.stride(0), UL.stride(1), - UR.data(), UR.stride(0), UR.stride(1), - W.data(), W.extent(0)); - } - }; - + template + KOKKOS_INLINE_FUNCTION + int + SerialEigendecomposition:: + invoke(const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W) { + /// view checking + const int m = A.extent(0); + assert(m == A.extent(1) && "Eigendecomposition: A is not square"); + assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); + + /// static assert A,er,ei,UL,UR,W has the same value_type + /// static assert all views have the same memory space + return SerialEigendecompositionInternal + ::invoke(A.extent(0), + A.data(), A.stride(0), A.stride(1), + er.data(), er.stride(0), + ei.data(), ei.stride(0), + UL.data(), UL.stride(0), UL.stride(1), + UR.data(), UR.stride(0), UR.stride(1), + W.data(), W.extent(0)); + } }/// end namespace Experimental } /// end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index c9a93654ce..807718c69f 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -78,6 +78,45 @@ namespace KokkosBatched { /// step 1: Hessenberg reduction A = Q H Q^H /// Q is stored in QZ +#if defined(KOKKOSKERNELS_ENABLE_TPL_MKL) && defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST) + { + real_type *t = w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t allocation fail"); + + if (as0 == 1 || as1 == 1) { /// if mkl can be interfaced, use it + const auto matrix_layout = ( as1 == 1 ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR ); + LAPACKE_dgehrd(matrix_layout, m, 1, m, A, m, t); + + SerialCopyInternal::invoke(m, m, QZ, qzs0, qzs1); + LAPACKE_dorghr(matrix_layout, m, 1, m, QZ, m, t); + } else { /// for arbitrary strides, there is no choice to use tpls + real_type *ww = w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace ww allocation fail"); + + SerialHessenbergInternal::invoke(m, m, + A, as0, as1, + t, 1, + ww); + + SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); + SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m-1, m-1, + A+as0, as0, as1, + t, 1, + QZ+qzs, qzs0, qzs1, + ww); + /// recovery of workspace for ww + w_now -= m; wlen_now += m; + } + /// recovery of workspace for t + w_now -= m; wlen_now += m; + + /// clean up H + SerialSetLowerTriangularInternal::invoke(m, m, + 2, + zero, + A, as0, as1); + } +#else { real_type *t = w_now; w_now += m; wlen_now -= m; real_type *ww = w_now; w_now += m; wlen_now -= m; @@ -104,7 +143,7 @@ namespace KokkosBatched { /// recover workspace w_now -= (2*m); wlen_now += (2*m); } - +#endif /// step 2: Schur decomposition H = Z T Z^H /// Z is applied to QZ { From 62f67998b773347107d3acba6745ee932af7e24e Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 20 Dec 2018 15:57:53 -0700 Subject: [PATCH 083/190] D2 Coloring work-in-progress checkpoint --- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 6 +- src/common/KokkosKernels_Handle.hpp | 29 +- src/graph/KokkosGraph_Distance2Color.hpp | 2 + .../KokkosGraph_Distance2GraphColorHandle.hpp | 461 ++++++++++++++++++ .../impl/KokkosGraph_Distance2Color_impl.hpp | 2 +- 5 files changed, 481 insertions(+), 19 deletions(-) create mode 100644 src/graph/KokkosGraph_Distance2GraphColorHandle.hpp diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp index 380cd33f6a..9f521b3799 100644 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp @@ -63,7 +63,7 @@ #include #include #include -#include +#include // EXPERIMENTAL (WCMCLEN) using namespace KokkosGraph; @@ -436,7 +436,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) double time_d2_degree; Kokkos::Impl::Timer timer; timer.reset(); - +/* typedef typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); @@ -445,7 +445,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, degree_d2_dist, degree_d2_max); - +*/ time_d2_degree = timer.seconds(); diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 59d4261bd8..99146baa03 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -154,16 +154,16 @@ class KokkosKernelsHandle{ } - typedef typename KokkosGraph::GraphColoringHandle - GraphColoringHandleType; - typedef typename KokkosSparse::GaussSeidelHandle - GaussSeidelHandleType; + typedef typename KokkosGraph:: + GraphColoringHandle + GraphColoringHandleType; + typedef typename KokkosSparse:: + GaussSeidelHandle + GaussSeidelHandleType; - typedef typename KokkosSparse::SPGEMMHandle - SPGEMMHandleType; + typedef typename KokkosSparse:: + SPGEMMHandle + SPGEMMHandleType; typedef typename Kokkos::View in_scalar_nnz_view_t; @@ -181,12 +181,11 @@ class KokkosKernelsHandle{ typedef typename Kokkos::View bool_persistent_view_t; typedef typename Kokkos::View bool_temp_view_t; - typedef typename KokkosSparse::SPADDHandle - SPADDHandleType; + typedef + typename KokkosSparse::SPADDHandle + SPADDHandleType; + + private: diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index c664b237ea..193cc069d0 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -49,6 +49,8 @@ #include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" +#include "KokkosGraph_Distance2ColorHandle.hpp" // todo work in progress (SCAFFOLDING) + namespace KokkosGraph{ namespace Experimental{ diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp new file mode 100644 index 0000000000..19b57b8992 --- /dev/null +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -0,0 +1,461 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#include +#include + +#include +#include +#include + +#ifndef _DISTANCE2GRAPHCOLORHANDLE_HPP +#define _DISTANCE2GRAPHCOLORHANDLE_HPP + +//#define VERBOSE +namespace KokkosGraph { + +//enum ColoringAlgorithm +enum GraphColoringAlgorithmDistance2 +{ + COLORING_D2_DEFAULT, // Distance-2 Graph Coloring default algorithm + COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring + COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) + COLORING_D2, // Distance-2 Graph Coloring + COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based + COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT + COLORING_D2_VB_BIT_EF, // Distance-2 Graph Coloring Vertex Based BIT + Edge Filtering +}; + + +enum ConflictList // TODO Can this go away? +{ + COLORING_NOCONFLICT, + COLORING_ATOMIC, + COLORING_PPS +}; + +enum ColoringType +{ + Distance1, + Distance2 +}; + +template +class Distance2GraphColoringHandle +{ + + public: + typedef ExecutionSpace HandleExecSpace; + typedef TemporaryMemorySpace HandleTempMemorySpace; + typedef PersistentMemorySpace HandlePersistentMemorySpace; + + + typedef typename std::remove_const::type size_type; + typedef const size_type const_size_type; + + typedef typename std::remove_const::type nnz_lno_t; + typedef const nnz_lno_t const_nnz_lno_t; + + typedef typename std::remove_const::type color_t; + typedef const color_t const_color_t; + + typedef typename Kokkos::View color_view_t; + + typedef typename color_view_t::array_layout color_view_array_layout; + typedef typename color_view_t::device_type color_view_device_t; + typedef typename color_view_t::memory_traits color_view_memory_traits; + typedef typename color_view_t::HostMirror color_host_view_t; // Host view type + + + typedef typename Kokkos::View size_type_temp_work_view_t; + typedef typename Kokkos::View size_type_persistent_work_view_t; + + typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; // Host view type + + typedef typename Kokkos::View nnz_lno_temp_work_view_t; + typedef typename Kokkos::View nnz_lno_persistent_work_view_t; + typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; // Host view type + + typedef Kokkos::TeamPolicy team_policy_t; + typedef typename team_policy_t::member_type team_member_t; + + typedef typename Kokkos::View non_const_1d_size_type_view_t; + + private: + ColoringType GraphColoringType; + + // Parameters + ColoringAlgorithm coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. + ConflictList conflict_list_type; // whether to use a conflict list or not, and + // if using it wheter to create it with atomic or parallel prefix sum. + + double min_reduction_for_conflictlist; + // if used pps is selected to create conflict list, what min percantage should be the vertex list + // be reduced, to create the new vertexlist. If it is reduced less than this percantage, use the + // previous array. + + int min_elements_for_conflictlist; + // minimum number of elements to create a new conflict list. + // if current conflict list size is smaller than this number, + // than we do not need to create a new conflict list. + + bool serial_conflict_resolution; // perform parallel greedy coloring once, then resolve conflict serially. + bool tictoc; // print time at every step + + bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. + + int vb_chunk_size; // the (minimum) size of the consecutive works that a thread will be assigned to. + int max_number_of_iterations; // maximum allowed number of phases that + + int eb_num_initial_colors; // the number of colors to assign at the beginning of the edge-based algorithm + + + // STATISTICS + double overall_coloring_time; // the overall time that it took to color the graph. In the case of the iterative calls. + double overall_coloring_time_phase1; // + double overall_coloring_time_phase2; // + double overall_coloring_time_phase3; // Some timer accumulators for internal phases. + double overall_coloring_time_phase4; // + double overall_coloring_time_phase5; // + double coloring_time; // the time that it took to color the graph + + int num_phases; // Number of phases used by the coloring algorithm + + + size_type size_of_edge_list; // todo not used? + + color_view_t vertex_colors; + bool is_coloring_called_before; + nnz_lno_t num_colors; + + + + public: + + + /** + * \brief Default constructor. + */ + Distance2GraphColoringHandle() + : GraphColoringType(Distance1) + , coloring_algorithm_type(COLORING_DEFAULT) + , conflict_list_type(COLORING_ATOMIC) + , min_reduction_for_conflictlist(0.35) + , min_elements_for_conflictlist(1000 /*5000*/) + , serial_conflict_resolution(true) + , tictoc(false) + , vb_edge_filtering(false) + , vb_chunk_size(8) + , max_number_of_iterations(200) + , eb_num_initial_colors(1) + , overall_coloring_time(0) + , overall_coloring_time_phase1(0) + , overall_coloring_time_phase2(0) + , overall_coloring_time_phase3(0) + , overall_coloring_time_phase4(0) + , overall_coloring_time_phase5(0) + , coloring_time(0) + , num_phases(0) + , size_of_edge_list(0) + , vertex_colors() + , is_coloring_called_before(false) + , num_colors(0) + { + this->choose_default_algorithm(); + this->set_defaults(this->coloring_algorithm_type); + } + + /** \brief Sets the graph coloring type. Whether it is distance-1 or distance-2 coloring. + * \param col_type: Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be + * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 + */ + void set_coloring_type(const ColoringType &col_type) { this->GraphColoringType = col_type; } + + /** \brief Gets the graph coloring type. Whether it is distance-1 or distance-2 coloring. + * returns Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be + * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 + */ + ColoringType get_coloring_type() { return this->GraphColoringType; } + + + /** \brief Changes the graph coloring algorithm. + * \param col_algo: Coloring algorithm: one of COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB + * \param set_default_parameters: whether or not to reset the default parameters for the given algorithm. + */ + void set_algorithm(const ColoringAlgorithm &col_algo, bool set_default_parameters = true) + { + if(col_algo == COLORING_DEFAULT) + { + this->choose_default_algorithm(); + } + else + { + this->coloring_algorithm_type = col_algo; + } + if(set_default_parameters) + { + this->set_defaults(this->coloring_algorithm_type); + } + } + + + + /** \brief Chooses best algorithm based on the execution space. COLORING_EB if cuda, COLORING_VB otherwise. + */ + void choose_default_algorithm() + { + #if defined(KOKKOS_ENABLE_SERIAL) + if(Kokkos::Impl::is_same::value) + { + this->coloring_algorithm_type = COLORING_SERIAL; + #ifdef VERBOSE + std::cout << "Serial Execution Space, Default Algorithm: COLORING_VB" << std::endl; + #endif + } + #endif + + #if defined(KOKKOS_ENABLE_THREADS) + if(Kokkos::Impl::is_same::value) + { + this->coloring_algorithm_type = COLORING_VB; + #ifdef VERBOSE + std::cout << "PTHREAD Execution Space, Default Algorithm: COLORING_VB" << std::endl; + #endif + } + #endif + + #if defined(KOKKOS_ENABLE_OPENMP) + if(Kokkos::Impl::is_same::value) + { + this->coloring_algorithm_type = COLORING_VB; + #ifdef VERBOSE + std::cout << "OpenMP Execution Space, Default Algorithm: COLORING_VB" << std::endl; + #endif + } + #endif + + #if defined(KOKKOS_ENABLE_CUDA) + if(Kokkos::Impl::is_same::value) + { + this->coloring_algorithm_type = COLORING_EB; + #ifdef VERBOSE + std::cout << "Cuda Execution Space, Default Algorithm: COLORING_VB" << std::endl; + #endif + } + #endif + + #if defined(KOKKOS_ENABLE_QTHREAD) + if(Kokkos::Impl::is_same::value) + { + this->coloring_algorithm_type = COLORING_VB; + #ifdef VERBOSE + std::cout << "Qthread Execution Space, Default Algorithm: COLORING_VB" << std::endl; + #endif + } + #endif + } + + + + nnz_lno_t get_num_colors() + { + if(num_colors == 0) + { + typedef typename Kokkos::RangePolicy my_exec_space; + Kokkos::parallel_reduce("KokkosKernels::FindMax", my_exec_space(0, vertex_colors.extent(0)), ReduceMaxFunctor(vertex_colors), num_colors); + } + return num_colors; + } + + + + /** \brief Sets Default Parameter settings for the given algorithm. + */ + void set_defaults(const ColoringAlgorithm &col_algo) + { + switch(col_algo) + { + case COLORING_D2_MATRIX_SQUARED: + case COLORING_D2_SERIAL: + case COLORING_D2: + case COLORING_D2_VB: + case COLORING_D2_VB_BIT: + case COLORING_D2_VB_BIT_EF: + this->conflict_list_type = COLORING_ATOMIC; + this->min_reduction_for_conflictlist = 0.35; + this->min_elements_for_conflictlist = 1000; + this->serial_conflict_resolution = false; + this->tictoc = false; + this->vb_edge_filtering = false; + this->vb_chunk_size = 8; + this->max_number_of_iterations = 200; + this->eb_num_initial_colors = 1; + break; + default: + throw std::runtime_error("Unknown Distance-2 Graph Coloring Algorithm\n"); + // break; + } + } + + + /** + * \brief Destructor + */ + virtual ~Distance2GraphColoringHandle(){}; + + // getters + ColoringAlgorithm get_coloring_algo_type() const { return this->coloring_algorithm_type; } + ConflictList get_conflict_list_type() const { return this->conflict_list_type; } + double get_min_reduction_for_conflictlist() const { return this->min_reduction_for_conflictlist; } + int get_min_elements_for_conflictlist() const { return this->min_elements_for_conflictlist; } + bool get_serial_conflict_resolution() const { return this->serial_conflict_resolution; } + bool get_tictoc() const { return this->tictoc; } + bool get_vb_edge_filtering() const { return this->vb_edge_filtering; } + int get_vb_chunk_size() const { return this->vb_chunk_size; } + int get_max_number_of_iterations() const { return this->max_number_of_iterations; } + int get_eb_num_initial_colors() const { return this->eb_num_initial_colors; } + + double get_overall_coloring_time() const { return this->overall_coloring_time; } + double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } + double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } + double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } + double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } + double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } + double get_coloring_time() const { return this->coloring_time; } + int get_num_phases() const { return this->num_phases; } + color_view_t get_vertex_colors() const { return this->vertex_colors; } + bool is_coloring_called() const { return this->is_coloring_called_before; } + + // setters + void set_coloring_algo_type(const ColoringAlgorithm &col_algo) { this->coloring_algorithm_type = col_algo; } + void set_conflict_list_type(const ConflictList &cl) { this->conflict_list_type = cl; } + void set_min_reduction_for_conflictlist(const double &min_reduction) { this->min_reduction_for_conflictlist = min_reduction; } + void set_min_elements_for_conflictlist(const int &min_elements) { this->min_elements_for_conflictlist = min_elements; } + void set_serial_conflict_resolution(const bool &use_serial_conflist_resolution) { this->serial_conflict_resolution = use_serial_conflist_resolution; } + void set_tictoc(const bool use_tictoc) { this->tictoc = use_tictoc; } + void set_vb_edge_filtering(const bool &use_vb_edge_filtering) { this->vb_edge_filtering = use_vb_edge_filtering; } + void set_vb_chunk_size(const int &chunksize) { this->vb_chunk_size = chunksize; } + void set_max_number_of_iterations(const int &max_phases) { this->max_number_of_iterations = max_phases; } + void set_eb_num_initial_colors(const int &num_initial_colors) { this->eb_num_initial_colors = num_initial_colors; } + void add_to_overall_coloring_time(const double &coloring_time_) { this->overall_coloring_time += coloring_time_; } + void add_to_overall_coloring_time_phase1(const double &coloring_time_) { this->overall_coloring_time_phase1 += coloring_time_; } + void add_to_overall_coloring_time_phase2(const double &coloring_time_) { this->overall_coloring_time_phase2 += coloring_time_; } + void add_to_overall_coloring_time_phase3(const double &coloring_time_) { this->overall_coloring_time_phase3 += coloring_time_; } + void add_to_overall_coloring_time_phase4(const double &coloring_time_) { this->overall_coloring_time_phase4 += coloring_time_; } + void add_to_overall_coloring_time_phase5(const double &coloring_time_) { this->overall_coloring_time_phase5 += coloring_time_; } + void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } + void set_num_phases(const double &num_phases_) { this->num_phases = num_phases_; } + + void set_vertex_colors(const color_view_t vertex_colors_) + { + this->vertex_colors = vertex_colors_; + this->is_coloring_called_before = true; + this->num_colors = 0; + } + + + // Print / write out the graph in a GraphVIZ format. + // Color "1" will be rendered as a red circle. + // Color "0" (uncolored) will be a star shape. + // Other node colors shown as just the color value. + // + // @param os use std::cout for output to STDOUT stream, or a ofstream object + // (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write + // to a file. + template + void graphToGraphviz(std::ostream &os, const index_t num_verts, rowmap_t &rowmap, entries_t &entries, kokkos_view_t &colors) const + { + typedef typename kokkos_view_t::HostMirror h_colors_t; + typedef typename rowmap_t::HostMirror h_rowmap_t; + typedef typename entries_t::HostMirror h_entries_t; + + h_colors_t h_colors = Kokkos::create_mirror_view(colors); + Kokkos::deep_copy(h_colors, colors); + + h_rowmap_t h_rowmap = Kokkos::create_mirror_view(rowmap); + Kokkos::deep_copy(h_rowmap, rowmap); + + h_entries_t h_entries = Kokkos::create_mirror_view(entries); + Kokkos::deep_copy(h_entries, entries); + + + os << "Graph G" << std::endl + << "{" << std::endl + << " rankdir=LR;" << std::endl + << " overlap=false;" << std::endl + << " splines=true;" << std::endl + << " maxiter=2000;" << std::endl + << " node [shape=Mrecord];" << std::endl + << " edge [len=2.0];" << std::endl + << std::endl; + + for(index_t vid = 0; vid < num_verts; vid++) + { + if(1 == h_colors(vid)) + { + os << " " << vid << " [ label=\"\", shape=circle, style=filled, color=red, fillcolor=red];" << std::endl; + } + else if(0 == h_colors(vid)) + { + os << " " << vid << " [ label=\"" << vid << "\", shape=star, style=filled, color=black];" << std::endl; + } + else + { + os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; + } + for(index_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) + { + index_t vadj = h_entries(iadj); + if(vadj >= vid) + { + os << " " << vid << " -- " << vadj << ";" << std::endl; + } + } + os << std::endl; + } + os << "}" << std::endl; + } // graphToGraphviz (end) +}; + +} // namespace KokkosGraph + +#endif // _GRAPHCOLORHANDLE_HPP diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 3f1f44a54a..f4c5c0bb9e 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -555,7 +555,7 @@ class GraphColorD2 size_t _degree_d2_max = 0; Kokkos::parallel_reduce("Max D2 Degree", this->nv, - KOKKOS_LAMBDA(const size_t &i, size_t &lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, + KOKKOS_LAMBDA(const size_t &i, size_t & lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, Kokkos::Max(_degree_d2_max)); degree_d2_max = _degree_d2_max; } From 3b4107a9f2d176790be7a5ab432f12cf5aa627df Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 7 Jan 2019 14:40:22 -0700 Subject: [PATCH 084/190] Checkpoint: Distance-2 Coloring --- src/common/KokkosKernels_Handle.hpp | 214 +++++++++++------- src/graph/KokkosGraph_Distance2Color.hpp | 29 +-- .../KokkosGraph_Distance2GraphColorHandle.hpp | 115 ++++------ .../impl/KokkosGraph_Distance2Color_impl.hpp | 108 +++------ 4 files changed, 210 insertions(+), 256 deletions(-) diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 99146baa03..45f6dad119 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -42,6 +42,7 @@ */ #include #include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_Distance2GraphColorHandle.hpp" #include "KokkosSparse_gauss_seidel_handle.hpp" #include "KokkosSparse_spgemm_handle.hpp" #include "KokkosSparse_spadd_handle.hpp" @@ -54,7 +55,8 @@ namespace Experimental{ template -class KokkosKernelsHandle{ +class KokkosKernelsHandle +{ public: typedef typename ExecutionSpace::execution_space HandleExecSpace; @@ -75,88 +77,91 @@ class KokkosKernelsHandle{ typedef const nnz_scalar_t const_nnz_scalar_t; template < typename right_size_type_, typename right_lno_t_, typename right_scalar_t_, - typename right_ExecutionSpace, typename right_TemporaryMemorySpace, typename right_PersistentMemorySpace> + typename right_ExecutionSpace, typename right_TemporaryMemorySpace, typename right_PersistentMemorySpace> //KokkosKernelsHandle &operator= KokkosKernelsHandle - (KokkosKernelsHandle & right_side_handle){ - - static_assert (std::is_same::value, - "Kernel handle left hand side should have const size type in assignment"); - static_assert (std::is_same::value, - "Kernel handle left hand side should have const lno type in assignment"); - static_assert (std::is_same::value, - "Kernel handle left hand side should have const scalar type in assignment"); - - static_assert (std::is_same::value, - "Kernel handle left hand side should have execution space in assignment"); - static_assert (std::is_same::value, - "Kernel handle left hand side should have temp memory space in assignment"); - static_assert (std::is_same::value, - "Kernel handle left hand side should have persistent memory space in assignment"); - - typedef typename std::remove_const::type nonconst_right_size_type; - typedef const nonconst_right_size_type const_right_size_type; - - typedef typename std::remove_const::type nonconst_right_lno_t; - typedef const nonconst_right_lno_t const_right_lno_t; - - typedef typename std::remove_const::type nonconst_right_scalar_t; - typedef const nonconst_right_scalar_t const_right_scalar_t; - - - - - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same size type in assignment"); - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same lno type in assignment"); - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same scalar type in assignment"); - - - - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same execution_space in assignment"); - /* - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same TemporaryMemorySpace in assignment"); - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same PersistentMemorySpace in assignment"); + (KokkosKernelsHandle & right_side_handle){ + + static_assert (std::is_same::value, + "Kernel handle left hand side should have const size type in assignment"); + static_assert (std::is_same::value, + "Kernel handle left hand side should have const lno type in assignment"); + static_assert (std::is_same::value, + "Kernel handle left hand side should have const scalar type in assignment"); + + static_assert (std::is_same::value, + "Kernel handle left hand side should have execution space in assignment"); + static_assert (std::is_same::value, + "Kernel handle left hand side should have temp memory space in assignment"); + static_assert (std::is_same::value, + "Kernel handle left hand side should have persistent memory space in assignment"); + + typedef typename std::remove_const::type nonconst_right_size_type; + typedef const nonconst_right_size_type const_right_size_type; + + typedef typename std::remove_const::type nonconst_right_lno_t; + typedef const nonconst_right_lno_t const_right_lno_t; + + typedef typename std::remove_const::type nonconst_right_scalar_t; + typedef const nonconst_right_scalar_t const_right_scalar_t; + + + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same size type in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same lno type in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same scalar type in assignment"); + + + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same execution_space in assignment"); + /* + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same TemporaryMemorySpace in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same PersistentMemorySpace in assignment"); */ - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same ExecutionSpace in assignment"); - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same TemporaryMemorySpace in assignment"); - static_assert (std::is_same::value, - "Kernel handle left and right sides should have same PersistentMemorySpace in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same ExecutionSpace in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same TemporaryMemorySpace in assignment"); + static_assert (std::is_same::value, + "Kernel handle left and right sides should have same PersistentMemorySpace in assignment"); - this->gcHandle = right_side_handle.get_graph_coloring_handle(); - this->gsHandle = right_side_handle.get_gs_handle(); - this->spgemmHandle = right_side_handle.get_spgemm_handle(); + this->gcHandle = right_side_handle.get_graph_coloring_handle(); + this->gcHandle_d2 = right_side_handle.get_distance2_graph_coloring_handle(); + this->gsHandle = right_side_handle.get_gs_handle(); + this->spgemmHandle = right_side_handle.get_spgemm_handle(); - this->team_work_size = right_side_handle.get_set_team_work_size(); - this->shared_memory_size = right_side_handle.get_shmem_size(); - this->suggested_team_size = right_side_handle.get_set_suggested_team_size(); - this->my_exec_space = right_side_handle.get_handle_exec_space(); - this->use_dynamic_scheduling = right_side_handle.is_dynamic_scheduling(); - this->KKVERBOSE = right_side_handle.get_verbose(); - this->vector_size = right_side_handle.get_set_suggested_vector_size(); + this->team_work_size = right_side_handle.get_set_team_work_size(); + this->shared_memory_size = right_side_handle.get_shmem_size(); + this->suggested_team_size = right_side_handle.get_set_suggested_team_size(); - is_owner_of_the_gc_handle = false; - is_owner_of_the_gs_handle = false; - is_owner_of_the_spgemm_handle = false; - is_owner_of_the_spadd_handle = false; - //return *this; + this->my_exec_space = right_side_handle.get_handle_exec_space(); + this->use_dynamic_scheduling = right_side_handle.is_dynamic_scheduling(); + this->KKVERBOSE = right_side_handle.get_verbose(); + this->vector_size = right_side_handle.get_set_suggested_vector_size(); + + is_owner_of_the_gc_handle = false; + is_owner_of_the_d2_gc_handle = false; + is_owner_of_the_gs_handle = false; + is_owner_of_the_spgemm_handle = false; + is_owner_of_the_spadd_handle = false; + //return *this; } typedef typename KokkosGraph:: GraphColoringHandle GraphColoringHandleType; + typedef typename KokkosGraph:: + Distance2GraphColoringHandle + Distance2GraphColoringHandleType; typedef typename KokkosSparse:: GaussSeidelHandle GaussSeidelHandleType; @@ -186,7 +191,6 @@ class KokkosKernelsHandle{ SPADDHandleType; - private: GraphColoringHandleType *gcHandle; @@ -204,6 +208,7 @@ class KokkosKernelsHandle{ int vector_size; bool is_owner_of_the_gc_handle; + bool is_owner_of_The_d2_gc_handle; bool is_owner_of_the_gs_handle; bool is_owner_of_the_spgemm_handle; bool is_owner_of_the_spadd_handle; @@ -211,20 +216,30 @@ class KokkosKernelsHandle{ public: - - - KokkosKernelsHandle(): - gcHandle(NULL), gsHandle(NULL),spgemmHandle(NULL),spaddHandle(NULL), - team_work_size (-1), shared_memory_size(16128), - suggested_team_size(-1), - my_exec_space(KokkosKernels::Impl::kk_get_exec_space_type()), - use_dynamic_scheduling(true), KKVERBOSE(false),vector_size(-1), - is_owner_of_the_gc_handle(true), is_owner_of_the_gs_handle(true), is_owner_of_the_spgemm_handle(true), - is_owner_of_the_spadd_handle(true) {} + KokkosKernelsHandle() + : gcHandle(NULL) + , gcHandle_d2(NULL) + , gsHandle(NULL) + , spgemmHandle(NULL) + , spaddHandle(NULL) + , team_work_size(-1) + , shared_memory_size(16128) + , suggested_team_size(-1) + , my_exec_space(KokkosKernels::Impl::kk_get_exec_space_type()) + , use_dynamic_scheduling(true) + , KKVERBOSE(false) + , vector_size(-1) + , is_owner_of_the_gc_handle(true) + , is_owner_of_the_d2_gc_handle(true) + , is_owner_of_the_gs_handle(true) + , is_owner_of_the_spgemm_handle(true) + , is_owner_of_the_spadd_handle(true) + { } ~KokkosKernelsHandle(){ this->destroy_gs_handle(); this->destroy_graph_coloring_handle(); + this->destroy_distance2_graph_coloring_handle(); this->destroy_spgemm_handle(); this->destroy_spadd_handle(); } @@ -270,7 +285,7 @@ class KokkosKernelsHandle{ * \param overall_work_size: The overall work size. */ int get_team_work_size(const int team_size, const int concurrency, const nnz_lno_t overall_work_size){ - if (this->team_work_size != -1){ + if (this->team_work_size != -1) { return this->team_work_size; } else { @@ -280,7 +295,6 @@ class KokkosKernelsHandle{ else { return 16; } - } } @@ -371,17 +385,15 @@ class KokkosKernelsHandle{ - + // SPGEM SPGEMMHandleType *get_spgemm_handle(){ return this->spgemmHandle; } - void create_spgemm_handle(KokkosSparse::SPGEMMAlgorithm spgemm_algo = KokkosSparse::SPGEMM_DEFAULT){ this->destroy_spgemm_handle(); this->is_owner_of_the_spgemm_handle = true; this->spgemmHandle = new SPGEMMHandleType(spgemm_algo); } - void destroy_spgemm_handle(){ if (is_owner_of_the_spgemm_handle && this->spgemmHandle != NULL){ delete this->spgemmHandle; @@ -389,6 +401,9 @@ class KokkosKernelsHandle{ } } + + + // Distance-1 Graph Coloring GraphColoringHandleType *get_graph_coloring_handle(){ return this->gcHandle; } @@ -408,6 +423,31 @@ class KokkosKernelsHandle{ } + + // Distance-2 Graph Coloring + Distance2GraphColoringHandleType *get_distance2_graph_coloring_handle() + { + return this->gcHandle_d2; + } + void create_distance2_graph_coloring_handle(KokkosGraph::GraphColoringAlgorithmDistance2 coloring_type = KokkosGraph::COLORING_D2_DEFAULT) + { + this->destroy_distance2_graph_coloring_handle(); + this->is_owner_of_The_d2_gc_handle = true; + this->gcHandle_d2 = new Distance2GraphColoringHandle(); + this->gcHandle_d2->set_algorithm(coloring_type, true); + this->gcHandle_d2->set_tictoc(KKVERBOSE); + } + void destroy_distance2_graph_coloring_handle() + { + if(is_owner_of_the_d2_gc_handle && this->gcHandle_d2 != NULL) + { + delete this->gcHandle_d2; + this->gcHandle_d2 = NULL; + } + } + + + GaussSeidelHandleType *get_gs_handle(){ return this->gsHandle; } @@ -428,16 +468,15 @@ class KokkosKernelsHandle{ } + SPADDHandleType *get_spadd_handle(){ return this->spaddHandle; } - void create_spadd_handle(bool input_sorted) { this->destroy_spadd_handle(); this->is_owner_of_the_spadd_handle = true; this->spaddHandle = new SPADDHandleType(input_sorted); } - void destroy_spadd_handle(){ if (is_owner_of_the_spadd_handle && this->spaddHandle != NULL) { @@ -446,7 +485,8 @@ class KokkosKernelsHandle{ } } -}; + +}; // end class KokkosKernelsHandle } } diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 193cc069d0..591b6ee96b 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -46,10 +46,11 @@ #include "KokkosGraph_GraphColor_impl.hpp" #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this +#include "KokkosGraph_Distance2GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" -#include "KokkosGraph_Distance2ColorHandle.hpp" // todo work in progress (SCAFFOLDING) + namespace KokkosGraph{ @@ -72,7 +73,8 @@ void graph_color_d2(KernelHandle *handle, Kokkos::Impl::Timer timer; // Set our handle pointer to a GraphColoringHandleType. - typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); +// typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); + typename KernelHandle::Distance2GraphColoringHandleType *gch = handle->get_distance2_graph_coloring_handle(); // Get the algorithm we're running from the graph coloring handle. ColoringAlgorithm algorithm = gch->get_coloring_algo_type(); @@ -80,7 +82,8 @@ void graph_color_d2(KernelHandle *handle, // Create a view to save the colors to. // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) // a 1D array of color_t - typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; +// typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; + typedef typename KernelHandle::Distance2GraphColoringHandleType::color_view_t color_view_type; color_view_type colors_out("Graph Colors", num_rows); gch->set_tictoc(handle->get_verbose()); @@ -99,16 +102,16 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_SERIAL: { #if defined KOKKOS_ENABLE_SERIAL - int num_phases = 0; - Impl::GraphColor - gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); - gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); - - // Save out the number of phases and vertex colors - gch->set_vertex_colors(colors_out); - gch->set_num_phases((double)num_phases); + int num_phases = 0; + Impl::GraphColor + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); + gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); + + // Save out the number of phases and vertex colors + gch->set_vertex_colors(colors_out); + gch->set_num_phases((double)num_phases); #else - throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); + throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); #endif break; } diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp index 19b57b8992..92c4be6513 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -50,10 +50,8 @@ #ifndef _DISTANCE2GRAPHCOLORHANDLE_HPP #define _DISTANCE2GRAPHCOLORHANDLE_HPP -//#define VERBOSE namespace KokkosGraph { -//enum ColoringAlgorithm enum GraphColoringAlgorithmDistance2 { COLORING_D2_DEFAULT, // Distance-2 Graph Coloring default algorithm @@ -66,16 +64,8 @@ enum GraphColoringAlgorithmDistance2 }; -enum ConflictList // TODO Can this go away? -{ - COLORING_NOCONFLICT, - COLORING_ATOMIC, - COLORING_PPS -}; - enum ColoringType { - Distance1, Distance2 }; @@ -125,20 +115,7 @@ class Distance2GraphColoringHandle // Parameters ColoringAlgorithm coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. - ConflictList conflict_list_type; // whether to use a conflict list or not, and - // if using it wheter to create it with atomic or parallel prefix sum. - - double min_reduction_for_conflictlist; - // if used pps is selected to create conflict list, what min percantage should be the vertex list - // be reduced, to create the new vertexlist. If it is reduced less than this percantage, use the - // previous array. - int min_elements_for_conflictlist; - // minimum number of elements to create a new conflict list. - // if current conflict list size is smaller than this number, - // than we do not need to create a new conflict list. - - bool serial_conflict_resolution; // perform parallel greedy coloring once, then resolve conflict serially. bool tictoc; // print time at every step bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. @@ -146,8 +123,6 @@ class Distance2GraphColoringHandle int vb_chunk_size; // the (minimum) size of the consecutive works that a thread will be assigned to. int max_number_of_iterations; // maximum allowed number of phases that - int eb_num_initial_colors; // the number of colors to assign at the beginning of the edge-based algorithm - // STATISTICS double overall_coloring_time; // the overall time that it took to color the graph. In the case of the iterative calls. @@ -176,17 +151,12 @@ class Distance2GraphColoringHandle * \brief Default constructor. */ Distance2GraphColoringHandle() - : GraphColoringType(Distance1) + : GraphColoringType(Distance2) , coloring_algorithm_type(COLORING_DEFAULT) - , conflict_list_type(COLORING_ATOMIC) - , min_reduction_for_conflictlist(0.35) - , min_elements_for_conflictlist(1000 /*5000*/) - , serial_conflict_resolution(true) , tictoc(false) , vb_edge_filtering(false) , vb_chunk_size(8) , max_number_of_iterations(200) - , eb_num_initial_colors(1) , overall_coloring_time(0) , overall_coloring_time_phase1(0) , overall_coloring_time_phase2(0) @@ -210,7 +180,7 @@ class Distance2GraphColoringHandle */ void set_coloring_type(const ColoringType &col_type) { this->GraphColoringType = col_type; } - /** \brief Gets the graph coloring type. Whether it is distance-1 or distance-2 coloring. + /** \brief Gets the graph coloring type. * returns Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 */ @@ -238,7 +208,6 @@ class Distance2GraphColoringHandle } - /** \brief Chooses best algorithm based on the execution space. COLORING_EB if cuda, COLORING_VB otherwise. */ void choose_default_algorithm() @@ -246,7 +215,7 @@ class Distance2GraphColoringHandle #if defined(KOKKOS_ENABLE_SERIAL) if(Kokkos::Impl::is_same::value) { - this->coloring_algorithm_type = COLORING_SERIAL; + this->coloring_algorithm_type = COLORING_D2_SERIAL; #ifdef VERBOSE std::cout << "Serial Execution Space, Default Algorithm: COLORING_VB" << std::endl; #endif @@ -256,7 +225,7 @@ class Distance2GraphColoringHandle #if defined(KOKKOS_ENABLE_THREADS) if(Kokkos::Impl::is_same::value) { - this->coloring_algorithm_type = COLORING_VB; + this->coloring_algorithm_type = COLORING_D2_VB_BIT; #ifdef VERBOSE std::cout << "PTHREAD Execution Space, Default Algorithm: COLORING_VB" << std::endl; #endif @@ -266,7 +235,7 @@ class Distance2GraphColoringHandle #if defined(KOKKOS_ENABLE_OPENMP) if(Kokkos::Impl::is_same::value) { - this->coloring_algorithm_type = COLORING_VB; + this->coloring_algorithm_type = COLORING_D2_VB_BIT; #ifdef VERBOSE std::cout << "OpenMP Execution Space, Default Algorithm: COLORING_VB" << std::endl; #endif @@ -276,7 +245,7 @@ class Distance2GraphColoringHandle #if defined(KOKKOS_ENABLE_CUDA) if(Kokkos::Impl::is_same::value) { - this->coloring_algorithm_type = COLORING_EB; + this->coloring_algorithm_type = COLORING_D2_VB_BIT; #ifdef VERBOSE std::cout << "Cuda Execution Space, Default Algorithm: COLORING_VB" << std::endl; #endif @@ -286,7 +255,7 @@ class Distance2GraphColoringHandle #if defined(KOKKOS_ENABLE_QTHREAD) if(Kokkos::Impl::is_same::value) { - this->coloring_algorithm_type = COLORING_VB; + this->coloring_algorithm_type = COLORING_D2_VB_BIT; #ifdef VERBOSE std::cout << "Qthread Execution Space, Default Algorithm: COLORING_VB" << std::endl; #endif @@ -320,19 +289,13 @@ class Distance2GraphColoringHandle case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: - this->conflict_list_type = COLORING_ATOMIC; - this->min_reduction_for_conflictlist = 0.35; - this->min_elements_for_conflictlist = 1000; - this->serial_conflict_resolution = false; this->tictoc = false; this->vb_edge_filtering = false; this->vb_chunk_size = 8; this->max_number_of_iterations = 200; - this->eb_num_initial_colors = 1; break; default: throw std::runtime_error("Unknown Distance-2 Graph Coloring Algorithm\n"); - // break; } } @@ -342,48 +305,49 @@ class Distance2GraphColoringHandle */ virtual ~Distance2GraphColoringHandle(){}; - // getters + // getters and setters ColoringAlgorithm get_coloring_algo_type() const { return this->coloring_algorithm_type; } - ConflictList get_conflict_list_type() const { return this->conflict_list_type; } - double get_min_reduction_for_conflictlist() const { return this->min_reduction_for_conflictlist; } - int get_min_elements_for_conflictlist() const { return this->min_elements_for_conflictlist; } - bool get_serial_conflict_resolution() const { return this->serial_conflict_resolution; } - bool get_tictoc() const { return this->tictoc; } - bool get_vb_edge_filtering() const { return this->vb_edge_filtering; } - int get_vb_chunk_size() const { return this->vb_chunk_size; } - int get_max_number_of_iterations() const { return this->max_number_of_iterations; } - int get_eb_num_initial_colors() const { return this->eb_num_initial_colors; } - - double get_overall_coloring_time() const { return this->overall_coloring_time; } - double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } - double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } - double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } - double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } - double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } - double get_coloring_time() const { return this->coloring_time; } - int get_num_phases() const { return this->num_phases; } + + double get_coloring_time() const { return this->coloring_time; } + int get_max_number_of_iterations() const { return this->max_number_of_iterations; } + int get_num_phases() const { return this->num_phases; } + + double get_overall_coloring_time() const { return this->overall_coloring_time; } + double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } + double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } + double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } + double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } + double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } + + bool get_tictoc() const { return this->tictoc; } + + int get_vb_chunk_size() const { return this->vb_chunk_size; } + + bool get_vb_edge_filtering() const { return this->vb_edge_filtering; } + color_view_t get_vertex_colors() const { return this->vertex_colors; } - bool is_coloring_called() const { return this->is_coloring_called_before; } + + bool is_coloring_called() const { return this->is_coloring_called_before; } // setters void set_coloring_algo_type(const ColoringAlgorithm &col_algo) { this->coloring_algorithm_type = col_algo; } - void set_conflict_list_type(const ConflictList &cl) { this->conflict_list_type = cl; } - void set_min_reduction_for_conflictlist(const double &min_reduction) { this->min_reduction_for_conflictlist = min_reduction; } - void set_min_elements_for_conflictlist(const int &min_elements) { this->min_elements_for_conflictlist = min_elements; } - void set_serial_conflict_resolution(const bool &use_serial_conflist_resolution) { this->serial_conflict_resolution = use_serial_conflist_resolution; } - void set_tictoc(const bool use_tictoc) { this->tictoc = use_tictoc; } - void set_vb_edge_filtering(const bool &use_vb_edge_filtering) { this->vb_edge_filtering = use_vb_edge_filtering; } - void set_vb_chunk_size(const int &chunksize) { this->vb_chunk_size = chunksize; } + + void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } void set_max_number_of_iterations(const int &max_phases) { this->max_number_of_iterations = max_phases; } - void set_eb_num_initial_colors(const int &num_initial_colors) { this->eb_num_initial_colors = num_initial_colors; } - void add_to_overall_coloring_time(const double &coloring_time_) { this->overall_coloring_time += coloring_time_; } + void set_num_phases(const double &num_phases_) { this->num_phases = num_phases_; } + + void add_to_overall_coloring_time(const double &coloring_time_) { this->overall_coloring_time += coloring_time_; } void add_to_overall_coloring_time_phase1(const double &coloring_time_) { this->overall_coloring_time_phase1 += coloring_time_; } void add_to_overall_coloring_time_phase2(const double &coloring_time_) { this->overall_coloring_time_phase2 += coloring_time_; } void add_to_overall_coloring_time_phase3(const double &coloring_time_) { this->overall_coloring_time_phase3 += coloring_time_; } void add_to_overall_coloring_time_phase4(const double &coloring_time_) { this->overall_coloring_time_phase4 += coloring_time_; } void add_to_overall_coloring_time_phase5(const double &coloring_time_) { this->overall_coloring_time_phase5 += coloring_time_; } - void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } - void set_num_phases(const double &num_phases_) { this->num_phases = num_phases_; } + + void set_tictoc(const bool use_tictoc) { this->tictoc = use_tictoc; } + + void set_vb_chunk_size(const int &chunksize) { this->vb_chunk_size = chunksize; } + + void set_vb_edge_filtering(const bool &use_vb_edge_filtering) { this->vb_edge_filtering = use_vb_edge_filtering; } void set_vertex_colors(const color_view_t vertex_colors_) { @@ -392,7 +356,6 @@ class Distance2GraphColoringHandle this->num_colors = 0; } - // Print / write out the graph in a GraphVIZ format. // Color "1" will be rendered as a red circle. // Color "0" (uncolored) will be a star shape. diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index f4c5c0bb9e..398874d8ae 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -55,10 +55,9 @@ #include -//#include - #include "KokkosGraph_GraphColor.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this +#include "KokkosGraph_Distance2GraphColorHandle.hpp" #include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2IMP_HPP @@ -72,7 +71,6 @@ namespace Impl { #define VB_D2_COLORING_FORBIDDEN_SIZE 64 #define VBBIT_D2_COLORING_FORBIDDEN_SIZE 64 -#define WCMCLEN_EXPERIMENTAL 0 /*! @@ -88,19 +86,19 @@ class GraphColorD2 typedef lno_row_view_t_ in_lno_row_view_t; typedef lno_nnz_view_t_ in_lno_nnz_view_t; - typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; - typedef typename HandleType::GraphColoringHandleType::color_t color_t; + typedef typename HandleType::Distance2GraphColoringHandleType::color_view_t color_view_type; + typedef typename HandleType::Distance2GraphColoringHandleType::color_t color_t; - typedef typename HandleType::GraphColoringHandleType::size_type size_type; - typedef typename HandleType::GraphColoringHandleType::nnz_lno_t nnz_lno_t; + typedef typename HandleType::Distance2GraphColoringHandleType::size_type size_type; + typedef typename HandleType::Distance2GraphColoringHandleType::nnz_lno_t nnz_lno_t; typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type - typedef typename HandleType::GraphColoringHandleType::color_host_view_t color_host_view_t; // host view type + typedef typename HandleType::Distance2GraphColoringHandleType::color_host_view_t color_host_view_t; // host view type - typedef typename HandleType::GraphColoringHandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::GraphColoringHandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::GraphColoringHandleType::const_size_type const_size_type; + typedef typename HandleType::Distance2GraphColoringHandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::Distance2GraphColoringHandleType::HandleTempMemorySpace MyTempMemorySpace; + typedef typename HandleType::Distance2GraphColoringHandleType::const_size_type const_size_type; typedef typename lno_row_view_t_::device_type row_lno_view_device_t; typedef typename lno_row_view_t_::const_type const_lno_row_view_t; @@ -111,7 +109,7 @@ class GraphColorD2 typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - typedef typename HandleType::GraphColoringHandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename HandleType::Distance2GraphColoringHandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; typedef typename Kokkos::View single_dim_index_view_type; typedef Kokkos::RangePolicy my_exec_space; @@ -120,8 +118,8 @@ class GraphColorD2 typedef typename team_policy_t::member_type team_member_t; typedef Kokkos::View non_const_1d_bool_view_t; - //typedef Kokkos::View non_const_1d_size_type_view_t; - typedef typename HandleType::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; + + typedef typename HandleType::Distance2GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; // For HashmapAccumulator typedef typename KokkosKernels::Impl::UniformMemoryPool pool_memory_space_t; // EXPERIMENTAL @@ -139,22 +137,16 @@ class GraphColorD2 const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap const_clno_nnz_view_t t_adj; // entries, transpose of entries - typename HandleType::GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle + typename HandleType::Distance2GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle + private: int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs int _max_num_iterations; - char _conflictList; // 0: none, 1: atomic (default), 2: parallel prefix sums (0, 2 not implemented) char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). bool _ticToc; // if true print info in each step -#if 0 - bool _degree_d2_is_set; - non_const_1d_size_type_view_t _degree_d2; - size_type _degree_d2_max; - size_type _degree_d2_sum; -#endif public: @@ -179,7 +171,6 @@ class GraphColorD2 ,gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()) ,_max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1) ,_use_color_set(0), _ticToc(handle->get_verbose()) -// ,_degree_d2_is_set(false), _degree_d2(NULL), _degree_d2_max(0), _degree_d2_sum(0) { } @@ -223,7 +214,6 @@ class GraphColorD2 { std::cout << "\tcolor_graph_d2 params:" << std::endl << "\t algorithm : " << (int)this->_use_color_set << std::endl - << "\t useConflictList : " << (int)this->_conflictList << std::endl << "\t ticToc : " << this->_ticToc << std::endl << "\t max_num_iterations : " << this->_max_num_iterations << std::endl << "\t chunkSize : " << this->_chunkSize << std::endl @@ -264,13 +254,9 @@ class GraphColorD2 // Size the next iteration conflictList single_dim_index_view_type next_iteration_recolorListLength; - // if we're using a conflictList - if(this->_conflictList > 0) - { - // Vertices to recolor. Will swap with vertexList - next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); - next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); - } + // Vertices to recolor. Will swap with vertexList + next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); + next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); nnz_lno_t numUncolored = this->nv; nnz_lno_t current_vertexListLength = this->nv; @@ -355,8 +341,8 @@ class GraphColorD2 timer.reset(); } - // If conflictList is used and we need to swap the work arrays - if(this->_conflictList && swap_work_arrays) + // Swap the work arrays (for conflictlist) + if(swap_work_arrays) { // Swap Work Arrays if(iter + 1 < this->_max_num_iterations) @@ -592,7 +578,7 @@ class GraphColorD2 void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) { MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); } @@ -711,40 +697,12 @@ class GraphColorD2 swap_work_arrays = true; nnz_lno_t output_numUncolored = 0; - // conflictList mode: - if(0 == this->_conflictList) + if(0 == this->_use_color_set) { - // Throw an error -- not implemented (yet) - std::ostringstream os; - os << "GraphColorD2::findConflicts() not implemented for conflictList == 0"; - Kokkos::Impl::throw_runtime_exception(os.str()); + functorFindConflicts_Atomic conf(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, next_iteration_recolorList_, next_iteration_recolorListLength_); + Kokkos::parallel_reduce("FindConflicts", my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); } - // conflictList mode: Parallel Prefix Sums (PPS) - else if(2 == this->_conflictList) - { - // Throw an error -- not implemented (yet) - std::ostringstream os; - os << "GraphColorD2::findConflicts() not implemented for conflictList == 2"; - Kokkos::Impl::throw_runtime_exception(os.str()); - } - - // conflictList mode: ATOMIC - else if(1 == this->_conflictList) - { - if(0 == this->_use_color_set) - { - functorFindConflicts_Atomic conf(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, next_iteration_recolorList_, next_iteration_recolorListLength_); - Kokkos::parallel_reduce("FindConflicts", my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); - } - } - else - { - // Throw an error becaue we should not be here... - std::ostringstream os; - os << "GraphColorD2::findConflicts() - unknown conflictList Flag value: " << this->_conflictList << " "; - Kokkos::Impl::throw_runtime_exception(os.str()); - } return output_numUncolored; } // findConflicts (end) @@ -771,12 +729,9 @@ class GraphColorD2 typename nnz_lno_temp_work_view_t::HostMirror h_recolor_list; - if(this->_conflictList) - { - end = current_vertexListLength_; - h_recolor_list = Kokkos::create_mirror_view(current_vertexList_); - Kokkos::deep_copy(h_recolor_list, current_vertexList_); - } + end = current_vertexListLength_; + h_recolor_list = Kokkos::create_mirror_view(current_vertexList_); + Kokkos::deep_copy(h_recolor_list, current_vertexList_); color_host_view_t h_colors = Kokkos::create_mirror_view(vertex_colors_); @@ -796,14 +751,7 @@ class GraphColorD2 for(nnz_lno_t k = 0; k < end; k++) { - if(this->_conflictList) - { - vid = h_recolor_list(k); - } - else - { - vid = k; // check for uncolored vertices - } + vid = h_recolor_list(k); if(h_colors(vid) > 0) continue; From c7bf47618caf2729666dae5dc7afccd345b36615 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 7 Jan 2019 21:24:11 -0700 Subject: [PATCH 085/190] 2019-01-07 Checkpoint (won't compile) --- src/common/KokkosKernels_Handle.hpp | 9 +- .../KokkosKernels_HashmapAccumulator.hpp | 3 +- src/graph/KokkosGraph_Distance2Color.hpp | 11 +- .../KokkosGraph_Distance2GraphColorHandle.hpp | 36 +- src/graph/KokkosGraph_GraphColor.hpp | 39 +-- src/graph/KokkosGraph_GraphColorHandle.hpp | 23 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 41 ++- .../impl/KokkosSparse_spgemm_impl_color.hpp | 14 +- unit_test/graph/Test_Graph_graph_color_d2.hpp | 322 ++++++++++-------- .../Test_Graph_graph_color_deterministic.hpp | 2 +- 10 files changed, 262 insertions(+), 238 deletions(-) diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 45f6dad119..4c753be8fe 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -160,7 +160,7 @@ class KokkosKernelsHandle GraphColoringHandle GraphColoringHandleType; typedef typename KokkosGraph:: - Distance2GraphColoringHandle + Distance2GraphColoringHandle Distance2GraphColoringHandleType; typedef typename KokkosSparse:: GaussSeidelHandle @@ -194,6 +194,7 @@ class KokkosKernelsHandle private: GraphColoringHandleType *gcHandle; + Distance2GraphColoringHandleType *gcHandle_d2; GaussSeidelHandleType *gsHandle; SPGEMMHandleType *spgemmHandle; SPADDHandleType *spaddHandle; @@ -208,7 +209,7 @@ class KokkosKernelsHandle int vector_size; bool is_owner_of_the_gc_handle; - bool is_owner_of_The_d2_gc_handle; + bool is_owner_of_the_d2_gc_handle; bool is_owner_of_the_gs_handle; bool is_owner_of_the_spgemm_handle; bool is_owner_of_the_spadd_handle; @@ -432,8 +433,8 @@ class KokkosKernelsHandle void create_distance2_graph_coloring_handle(KokkosGraph::GraphColoringAlgorithmDistance2 coloring_type = KokkosGraph::COLORING_D2_DEFAULT) { this->destroy_distance2_graph_coloring_handle(); - this->is_owner_of_The_d2_gc_handle = true; - this->gcHandle_d2 = new Distance2GraphColoringHandle(); + this->is_owner_of_the_d2_gc_handle = true; + this->gcHandle_d2 = new Distance2GraphColoringHandleType(); this->gcHandle_d2->set_algorithm(coloring_type, true); this->gcHandle_d2->set_tictoc(KKVERBOSE); } diff --git a/src/common/KokkosKernels_HashmapAccumulator.hpp b/src/common/KokkosKernels_HashmapAccumulator.hpp index f1bd94cd94..0baba3e790 100644 --- a/src/common/KokkosKernels_HashmapAccumulator.hpp +++ b/src/common/KokkosKernels_HashmapAccumulator.hpp @@ -739,4 +739,5 @@ struct HashmapAccumulator } // namespace Experimental -} // namespace KokkosKernels \ No newline at end of file +} // namespace KokkosKernels + diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 591b6ee96b..97ae3e482a 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -52,9 +52,9 @@ -namespace KokkosGraph{ +namespace KokkosGraph { -namespace Experimental{ +namespace Experimental { /** @@ -73,11 +73,11 @@ void graph_color_d2(KernelHandle *handle, Kokkos::Impl::Timer timer; // Set our handle pointer to a GraphColoringHandleType. -// typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); + typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); typename KernelHandle::Distance2GraphColoringHandleType *gch = handle->get_distance2_graph_coloring_handle(); // Get the algorithm we're running from the graph coloring handle. - ColoringAlgorithm algorithm = gch->get_coloring_algo_type(); + GraphColoringAlgorithmDistance2 algorithm = gch->get_coloring_algo_type(); // Create a view to save the colors to. // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) @@ -90,7 +90,6 @@ void graph_color_d2(KernelHandle *handle, switch(algorithm) { - case COLORING_SPGEMM: case COLORING_D2_MATRIX_SQUARED: { Impl::GraphColorD2_MatrixSquared @@ -104,7 +103,7 @@ void graph_color_d2(KernelHandle *handle, #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; Impl::GraphColor - gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); // Save out the number of phases and vertex colors diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp index 92c4be6513..739865fe83 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -52,11 +52,13 @@ namespace KokkosGraph { + + enum GraphColoringAlgorithmDistance2 { COLORING_D2_DEFAULT, // Distance-2 Graph Coloring default algorithm - COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) + COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring COLORING_D2, // Distance-2 Graph Coloring COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT @@ -64,10 +66,6 @@ enum GraphColoringAlgorithmDistance2 }; -enum ColoringType -{ - Distance2 -}; template class Distance2GraphColoringHandle @@ -111,10 +109,9 @@ class Distance2GraphColoringHandle typedef typename Kokkos::View non_const_1d_size_type_view_t; private: - ColoringType GraphColoringType; // Parameters - ColoringAlgorithm coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. + GraphColoringAlgorithmDistance2 coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. bool tictoc; // print time at every step @@ -151,8 +148,7 @@ class Distance2GraphColoringHandle * \brief Default constructor. */ Distance2GraphColoringHandle() - : GraphColoringType(Distance2) - , coloring_algorithm_type(COLORING_DEFAULT) + : coloring_algorithm_type(COLORING_D2_DEFAULT) , tictoc(false) , vb_edge_filtering(false) , vb_chunk_size(8) @@ -174,26 +170,14 @@ class Distance2GraphColoringHandle this->set_defaults(this->coloring_algorithm_type); } - /** \brief Sets the graph coloring type. Whether it is distance-1 or distance-2 coloring. - * \param col_type: Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be - * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 - */ - void set_coloring_type(const ColoringType &col_type) { this->GraphColoringType = col_type; } - - /** \brief Gets the graph coloring type. - * returns Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be - * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 - */ - ColoringType get_coloring_type() { return this->GraphColoringType; } - /** \brief Changes the graph coloring algorithm. * \param col_algo: Coloring algorithm: one of COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB * \param set_default_parameters: whether or not to reset the default parameters for the given algorithm. */ - void set_algorithm(const ColoringAlgorithm &col_algo, bool set_default_parameters = true) + void set_algorithm(const GraphColoringAlgorithmDistance2 &col_algo, bool set_default_parameters = true) { - if(col_algo == COLORING_DEFAULT) + if(col_algo == COLORING_D2_DEFAULT) { this->choose_default_algorithm(); } @@ -279,7 +263,7 @@ class Distance2GraphColoringHandle /** \brief Sets Default Parameter settings for the given algorithm. */ - void set_defaults(const ColoringAlgorithm &col_algo) + void set_defaults(const GraphColoringAlgorithmDistance2 &col_algo) { switch(col_algo) { @@ -306,7 +290,7 @@ class Distance2GraphColoringHandle virtual ~Distance2GraphColoringHandle(){}; // getters and setters - ColoringAlgorithm get_coloring_algo_type() const { return this->coloring_algorithm_type; } + GraphColoringAlgorithmDistance2 get_coloring_algo_type() const { return this->coloring_algorithm_type; } double get_coloring_time() const { return this->coloring_time; } int get_max_number_of_iterations() const { return this->max_number_of_iterations; } @@ -330,7 +314,7 @@ class Distance2GraphColoringHandle bool is_coloring_called() const { return this->is_coloring_called_before; } // setters - void set_coloring_algo_type(const ColoringAlgorithm &col_algo) { this->coloring_algorithm_type = col_algo; } + void set_coloring_algo_type(const GraphColoringAlgorithmDistance2 &col_algo) { this->coloring_algorithm_type = col_algo; } void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } void set_max_number_of_iterations(const int &max_phases) { this->max_number_of_iterations = max_phases; } diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_GraphColor.hpp index a47fc55113..ec24ee2cbe 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_GraphColor.hpp @@ -86,11 +86,11 @@ void graph_color_symbolic( gc = new BaseGraphColoring(num_rows, entries.extent(0), row_map, entries, gch); break; - case COLORING_SERIAL2: - gc = new Impl::GraphColor2( - num_rows, entries.extent(0), - row_map, entries, gch); - break; +// case COLORING_SERIAL2: +// gc = new Impl::GraphColor2( +// num_rows, entries.extent(0), +// row_map, entries, gch); +// break; case COLORING_VB: case COLORING_VBBIT: @@ -110,27 +110,6 @@ void graph_color_symbolic( gc = new EBGraphColoring(num_rows, entries.extent(0),row_map, entries, gch); break; - case COLORING_SPGEMM: - case COLORING_D2_MATRIX_SQUARED: - //std::cout << ">>> WCMCLEN graph_color_symbolic (KokkosGraph_graph_color.hpp) [ COLORING_SPGEMM / COLORING_D2_MATRIX_SQUARED ]" << std::endl; - - if (handle->get_handle_exec_space() == KokkosKernels::Impl::Exec_CUDA) { - typedef typename Impl::GraphColor_EB EBGraphColoringSPGEMM; - gc = new EBGraphColoringSPGEMM(num_rows, entries.extent(0),row_map, entries, gch); - } else { - typedef typename Impl::GraphColor_VB VBGraphColoringSPGEMM; - gc = new VBGraphColoringSPGEMM(num_rows, entries.extent(0), row_map, entries, gch); - } - break; - -// case COLORING_D2_WCMCLEN: -// { -// std::ostringstream os; -// os << ">>> WCMCLEN graph_color_symbolic (KokkosGraph_graph_color.hpp) COLORING_D2_WCMCLEN not implemented"; -// Kokkos::Impl::throw_runtime_exception(os.str()); -// } -// break; - case COLORING_DEFAULT: break; @@ -164,8 +143,7 @@ void graph_color( } - -// initial distance 2 graph coloring -- serial only (work in progress) - wcmclen +// Distance 2 graph coloring -- serial only -- should be replaced by the Distance2GraphColoring template @@ -205,7 +183,7 @@ void d2_graph_color( break; } - case COLORING_SERIAL2: // WCMCLEN: for now we don't need to worry about this optimization. + case COLORING_SERIAL2: { color_view_type colors_out = color_view_type("Graph Colors", num_rows); Impl::GraphColor2 @@ -225,7 +203,6 @@ void d2_graph_color( gch->set_vertex_colors(colors_out); break; } - } double coloring_time = timer.seconds(); @@ -233,6 +210,8 @@ void d2_graph_color( gch->set_coloring_time(coloring_time); } + + } // end namespace Experimental } // end namespace KokkosGraph diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 2a0be0b8f8..8c6422e5ea 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -63,12 +63,6 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_EB, // Edge Based Coloring COLORING_SERIAL2, COLORING_SPGEMM, - COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring - COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) - COLORING_D2, // Distance-2 Graph Coloring - COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based - COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT - COLORING_D2_VB_BIT_EF, // Distance-2 Graph Coloring Vertex Based BIT + Edge Filtering }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -169,7 +163,6 @@ class GraphColoringHandle nnz_lno_t num_colors; - public: @@ -635,14 +628,14 @@ class GraphColoringHandle case COLORING_VBD: case COLORING_VBDBIT: case COLORING_SERIAL: - case COLORING_SERIAL2: - case COLORING_SPGEMM: - case COLORING_D2_MATRIX_SQUARED: - case COLORING_D2_SERIAL: - case COLORING_D2: - case COLORING_D2_VB: - case COLORING_D2_VB_BIT: - case COLORING_D2_VB_BIT_EF: +// case COLORING_SERIAL2: +// case COLORING_SPGEMM: +// case COLORING_D2_MATRIX_SQUARED: +// case COLORING_D2_SERIAL: +// case COLORING_D2: +// case COLORING_D2_VB: +// case COLORING_D2_VB_BIT: +// case COLORING_D2_VB_BIT_EF: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 398874d8ae..314eaf8110 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -40,6 +40,9 @@ // ************************************************************************ //@HEADER */ +#ifndef _KOKKOSCOLORINGD2IMP_HPP +#define _KOKKOSCOLORINGD2IMP_HPP + #include #include #include @@ -60,9 +63,6 @@ #include "KokkosGraph_Distance2GraphColorHandle.hpp" #include "KokkosKernels_Handle.hpp" -#ifndef _KOKKOSCOLORINGD2IMP_HPP -#define _KOKKOSCOLORINGD2IMP_HPP - namespace KokkosGraph { @@ -142,10 +142,10 @@ class GraphColorD2 private: - int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs + int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs int _max_num_iterations; - char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). - bool _ticToc; // if true print info in each step + char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). + bool _ticToc; // if true print info in each step public: @@ -159,18 +159,27 @@ class GraphColorD2 * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorD2(nnz_lno_t nv_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, + GraphColorD2(nnz_lno_t nv_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, const_clno_row_view_t t_row_map, const_clno_nnz_view_t t_entries, - HandleType *handle) - : nv(nv_), nr(nv_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries) - ,gc_handle(handle->get_graph_coloring_handle()), _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()) - ,_max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()), _conflictList(1) - ,_use_color_set(0), _ticToc(handle->get_verbose()) + HandleType* handle) + : nv(nv_) + , nr(nv_) + , nc(nc_) + , ne(ne_) + , xadj(row_map) + , adj(entries) + , t_xadj(t_row_map) + , t_adj(t_entries) + , gc_handle(handle->get_graph_coloring_handle()) + , _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()) + , _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()) + , _use_color_set(0) + , _ticToc(handle->get_verbose()) { } diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index 8762012c2d..9d8913d68e 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -510,14 +510,16 @@ void typename HandleType::GraphColoringHandleType::color_view_t vertex_color_view; if (this->handle->get_spgemm_handle()->coloring_input_file == ""){ - handle->get_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_SERIAL2); //for now only sequential one exists. //find distance-2 graph coloring - KokkosGraph::Experimental::d2_graph_color - - (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); + handle->get_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_SERIAL2); + KokkosGraph::Experimental::d2_graph_color + (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); + + // WCMCLEN: SCAFFOLDING +// handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); +// KokkosGraph::Experimental::graph_color_d2 +// (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); original_num_colors = handle->get_graph_coloring_handle()->get_num_colors(); diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_d2.hpp index 2d6ad1a9d4..e95c004758 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_d2.hpp @@ -56,90 +56,121 @@ using namespace KokkosKernels::Experimental; using namespace KokkosGraph; using namespace KokkosGraph::Experimental; -namespace Test { -template -int run_graphcolor_d2( - crsMat_t input_mat, - ColoringAlgorithm coloring_algorithm, - size_t &num_colors, - typename crsMat_t::StaticCrsGraphType::entries_type::non_const_type & vertex_colors){ - typedef typename crsMat_t::StaticCrsGraphType graph_t; - typedef typename graph_t::row_map_type lno_view_t; - typedef typename graph_t::entries_type lno_nnz_view_t; - typedef typename crsMat_t::values_type::non_const_type scalar_view_t; - - typedef typename lno_view_t::value_type size_type; - typedef typename lno_nnz_view_t::value_type lno_t; - typedef typename scalar_view_t::value_type scalar_t; - - - typedef KokkosKernelsHandle - KernelHandle; - - KernelHandle kh; - kh.set_team_work_size(16); - kh.set_dynamic_scheduling(true); - kh.create_graph_coloring_handle(coloring_algorithm); - - - const size_t num_rows_1 = input_mat.numRows(); - const size_t num_cols_1 = input_mat.numCols(); +namespace Test { - graph_color_d2 - (&kh,num_rows_1, num_cols_1, - input_mat.graph.row_map, input_mat.graph.entries, input_mat.graph.row_map, input_mat.graph.entries); - num_colors = kh.get_graph_coloring_handle()->get_num_colors(); - vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors(); - kh.destroy_graph_coloring_handle(); - return 0; +template +int +run_graphcolor_d2(crsMat_t input_mat, + GraphColoringAlgorithmDistance2 coloring_algorithm, + size_t& num_colors, + typename crsMat_t::StaticCrsGraphType::entries_type::non_const_type& vertex_colors) +{ + typedef typename crsMat_t::StaticCrsGraphType graph_t; + typedef typename graph_t::row_map_type lno_view_t; + typedef typename graph_t::entries_type lno_nnz_view_t; + typedef typename crsMat_t::values_type::non_const_type scalar_view_t; + + typedef typename lno_view_t::value_type size_type; + typedef typename lno_nnz_view_t::value_type lno_t; + typedef typename scalar_view_t::value_type scalar_t; + + + typedef KokkosKernelsHandle + KernelHandle; + + KernelHandle kh; + kh.set_team_work_size(16); + kh.set_dynamic_scheduling(true); + + kh.create_distance2_graph_coloring_handle(coloring_algorithm); + + const size_t num_rows_1 = input_mat.numRows(); + const size_t num_cols_1 = input_mat.numCols(); + + graph_color_d2(&kh, + num_rows_1, + num_cols_1, + input_mat.graph.row_map, + input_mat.graph.entries, + input_mat.graph.row_map, + input_mat.graph.entries); + + num_colors = kh.get_graph_coloring_handle()->get_num_colors(); + vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors(); + kh.destroy_graph_coloring_handle(); + return 0; } -} +} // namespace Test -template -void test_coloring_d2(lno_t numRows,size_type nnz, lno_t bandwidth, lno_t row_size_variance) { - using namespace Test; - typedef typename KokkosSparse::CrsMatrix crsMat_t; - typedef typename crsMat_t::StaticCrsGraphType graph_t; - typedef typename graph_t::row_map_type lno_view_t; - typedef typename graph_t::entries_type lno_nnz_view_t; - typedef typename graph_t::entries_type::non_const_type color_view_t; - typedef typename crsMat_t::values_type::non_const_type scalar_view_t; - //typedef typename lno_view_t::non_const_value_type size_type; +template +void +test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_variance) +{ + using namespace Test; + typedef typename KokkosSparse::CrsMatrix crsMat_t; + typedef typename crsMat_t::StaticCrsGraphType graph_t; + typedef typename graph_t::row_map_type lno_view_t; + typedef typename graph_t::entries_type lno_nnz_view_t; + typedef typename graph_t::entries_type::non_const_type color_view_t; + typedef typename crsMat_t::values_type::non_const_type scalar_view_t; + // typedef typename lno_view_t::non_const_value_type size_type; - lno_t numCols = numRows; - crsMat_t input_mat = KokkosKernels::Impl::kk_generate_sparse_matrix(numRows,numCols,nnz,row_size_variance, bandwidth); - typename lno_view_t::non_const_type sym_xadj; - typename lno_nnz_view_t::non_const_type sym_adj; - KokkosKernels::Impl::symmetrize_graph_symbolic_hashmap - (numRows, input_mat.graph.row_map, input_mat.graph.entries, sym_xadj, sym_adj); - size_type numentries = sym_adj.extent(0); - scalar_view_t newValues("vals", numentries); + lno_t numCols = numRows; + crsMat_t input_mat = + KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); - graph_t static_graph (sym_adj, sym_xadj); - input_mat = crsMat_t("CrsMatrix", numCols, newValues, static_graph); + typename lno_view_t::non_const_type sym_xadj; + typename lno_nnz_view_t::non_const_type sym_adj; - ColoringAlgorithm coloring_algorithms[] = {COLORING_SPGEMM, COLORING_D2}; + KokkosKernels::Impl::symmetrize_graph_symbolic_hashmap( + numRows, input_mat.graph.row_map, input_mat.graph.entries, sym_xadj, sym_adj); + size_type numentries = sym_adj.extent(0); + scalar_view_t newValues("vals", numentries); + graph_t static_graph(sym_adj, sym_xadj); + input_mat = crsMat_t("CrsMatrix", numCols, newValues, static_graph); - typedef KokkosKernelsHandle - KernelHandle; + typedef KokkosKernelsHandle + KernelHandle; - KernelHandle cp; + KernelHandle cp; std::string algName = "SPGEMM_KK_MEMSPEED"; cp.create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); - typename graph_t::row_map_type::non_const_type cRowptrs("cRowptrs", numRows+1); + typename graph_t::row_map_type::non_const_type cRowptrs("cRowptrs", numRows + 1); // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) - KokkosSparse::Experimental::spgemm_symbolic(&cp, numRows, numRows, numRows, input_mat.graph.row_map, input_mat.graph.entries, false, input_mat.graph.row_map, input_mat.graph.entries, false, cRowptrs); + KokkosSparse::Experimental::spgemm_symbolic(&cp, + numRows, + numRows, + numRows, + input_mat.graph.row_map, + input_mat.graph.entries, + false, + input_mat.graph.row_map, + input_mat.graph.entries, + false, + cRowptrs); // Get num nz in C auto Cnnz = cp.get_spgemm_handle()->get_c_nnz(); // Must create placeholder value views for A and C (values are meaningless) @@ -147,102 +178,127 @@ void test_coloring_d2(lno_t numRows,size_type nnz, lno_t bandwidth, lno_t row_si scalar_view_t aFakeValues("A/B placeholder values (meaningless)", input_mat.graph.entries.size()); // Allocate C entries array, and placeholder values typename graph_t::entries_type::non_const_type cColinds("C colinds", Cnnz); - scalar_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + scalar_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); // Run the numeric kernel - KokkosSparse::Experimental::spgemm_numeric(&cp, numRows, numRows, numRows, input_mat.graph.row_map, input_mat.graph.entries, aFakeValues, false, input_mat.graph.row_map, input_mat.graph.entries, - aFakeValues, false, cRowptrs, cColinds, cFakeValues); - // done with spgemm - cp.destroy_spgemm_handle(); - - int num_algorithms = 2; + KokkosSparse::Experimental::spgemm_numeric(&cp, + numRows, + numRows, + numRows, + input_mat.graph.row_map, + input_mat.graph.entries, + aFakeValues, + false, + input_mat.graph.row_map, + input_mat.graph.entries, + aFakeValues, + false, + cRowptrs, + cColinds, + cFakeValues); + // done with spgemm + cp.destroy_spgemm_handle(); + + GraphColoringAlgorithmDistance2 coloring_algorithms[] = { COLORING_D2_MATRIX_SQUARED, + COLORING_D2_SERIAL, + COLORING_D2, + COLORING_D2_VB, + COLORING_D2_VB_BIT }; + + int num_algorithms = 5; + + for(int ii = 0; ii < num_algorithms; ++ii) + { - for (int ii = 0; ii < num_algorithms; ++ii){ + GraphColoringAlgorithmDistance2 coloring_algorithm = coloring_algorithms[ ii ]; + color_view_t vector_colors; + size_t num_colors; - ColoringAlgorithm coloring_algorithm = coloring_algorithms[ii]; - color_view_t vector_colors; - size_t num_colors; + Kokkos::Impl::Timer timer1; + crsMat_t output_mat; + int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); + // double coloring_time = timer1.seconds(); + EXPECT_TRUE((res == 0)); - Kokkos::Impl::Timer timer1; - crsMat_t output_mat; - int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); - //double coloring_time = timer1.seconds(); - EXPECT_TRUE( (res == 0)); + const lno_t num_rows_1 = input_mat.numRows(); + const lno_t num_cols_1 = input_mat.numCols(); - const lno_t num_rows_1 = input_mat.numRows(); - const lno_t num_cols_1 = input_mat.numCols(); + lno_t num_conflict = KokkosKernels::Impl:: + kk_is_d1_coloring_valid( + num_rows_1, num_cols_1, cRowptrs, cColinds, vector_colors); - lno_t num_conflict = KokkosKernels::Impl::kk_is_d1_coloring_valid (num_rows_1, num_cols_1, cRowptrs, cColinds, vector_colors); + lno_t conf = 0; + { + // also check the correctness of the validation code :) + typename lno_view_t::HostMirror hrm = Kokkos::create_mirror_view(cRowptrs); + typename lno_nnz_view_t::HostMirror hentries = Kokkos::create_mirror_view(cColinds); + typename color_view_t::HostMirror hcolor = Kokkos::create_mirror_view(vector_colors); + Kokkos::deep_copy(hrm, cRowptrs); + Kokkos::deep_copy(hentries, cColinds); + Kokkos::deep_copy(hcolor, vector_colors); - lno_t conf = 0; - { - //also check the correctness of the validation code :) - typename lno_view_t::HostMirror hrm = Kokkos::create_mirror_view (cRowptrs); - typename lno_nnz_view_t::HostMirror hentries = Kokkos::create_mirror_view (cColinds); - typename color_view_t::HostMirror hcolor = Kokkos::create_mirror_view (vector_colors); - Kokkos::deep_copy (hrm , cRowptrs); - Kokkos::deep_copy (hentries , cColinds); - Kokkos::deep_copy (hcolor , vector_colors); - - for (lno_t i = 0; i < num_rows_1; ++i){ - const size_type b = hrm(i); - const size_type e = hrm(i + 1); - for (size_type j = b; j < e; ++j){ - lno_t d = hentries(j); - if (i != d){ - if (hcolor(d) == hcolor(i)){ - conf++; + for(lno_t i = 0; i < num_rows_1; ++i) + { + const size_type b = hrm(i); + const size_type e = hrm(i + 1); + for(size_type j = b; j < e; ++j) + { + lno_t d = hentries(j); + if(i != d) + { + if(hcolor(d) == hcolor(i)) + { + conf++; + } + } + } } - } } - } - } - - EXPECT_TRUE( (num_conflict == conf)); - EXPECT_TRUE( (num_conflict == 0)); -/* - ::testing::internal::CaptureStdout(); - std::cout << "num_colors:" << num_colors << " num_conflict:" << num_conflict << " conf:" << conf << std::endl; - std::string capturedStdout = ::testing::internal::GetCapturedStdout().c_str(); - EXPECT_STREQ("something", capturedStdout.c_str()); -*/ + EXPECT_TRUE((num_conflict == conf)); - } + EXPECT_TRUE((num_conflict == 0)); + /* + ::testing::internal::CaptureStdout(); + std::cout << "num_colors:" << num_colors << " num_conflict:" << num_conflict << " conf:" << conf << std::endl; + std::string capturedStdout = ::testing::internal::GetCapturedStdout().c_str(); + EXPECT_STREQ("something", capturedStdout.c_str()); + */ + } - - //device::execution_space::finalize(); + // device::execution_space::finalize(); } -#define EXECUTE_TEST(SCALAR, ORDINAL, OFFSET, DEVICE) \ -TEST_F( TestCategory, graph ## _ ## graph_color_d2 ## _ ## SCALAR ## _ ## ORDINAL ## _ ## OFFSET ## _ ## DEVICE ) { \ - test_coloring_d2(50000, 50000 * 30, 200, 10); \ - test_coloring_d2(50000, 50000 * 30, 100, 10); \ -} +#define EXECUTE_TEST(SCALAR, ORDINAL, OFFSET, DEVICE) \ + TEST_F(TestCategory, graph##_##graph_color_d2##_##SCALAR##_##ORDINAL##_##OFFSET##_##DEVICE) \ + { \ + test_coloring_d2(50000, 50000 * 30, 200, 10); \ + test_coloring_d2(50000, 50000 * 30, 100, 10); \ + } #if defined(KOKKOSKERNELS_INST_DOUBLE) -#if (defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ - && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) - EXECUTE_TEST(double, int, int, TestExecSpace) +#if(defined(KOKKOSKERNELS_INST_ORDINAL_INT) && defined(KOKKOSKERNELS_INST_OFFSET_INT)) \ + || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +EXECUTE_TEST(double, int, int, TestExecSpace) #endif -#if (defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ - && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) - EXECUTE_TEST(double, int64_t, int, TestExecSpace) +#if(defined(KOKKOSKERNELS_INST_ORDINAL_INT64_T) && defined(KOKKOSKERNELS_INST_OFFSET_INT)) \ + || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +EXECUTE_TEST(double, int64_t, int, TestExecSpace) #endif -#if (defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ - && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) - EXECUTE_TEST(double, int, size_t, TestExecSpace) +#if(defined(KOKKOSKERNELS_INST_ORDINAL_INT) && defined(KOKKOSKERNELS_INST_OFFSET_SIZE_T)) \ + || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +EXECUTE_TEST(double, int, size_t, TestExecSpace) #endif -#if (defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ - && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) - EXECUTE_TEST(double, int64_t, size_t, TestExecSpace) +#if(defined(KOKKOSKERNELS_INST_ORDINAL_INT64_T) && defined(KOKKOSKERNELS_INST_OFFSET_SIZE_T)) \ + || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +EXECUTE_TEST(double, int64_t, size_t, TestExecSpace) #endif #endif diff --git a/unit_test/graph/Test_Graph_graph_color_deterministic.hpp b/unit_test/graph/Test_Graph_graph_color_deterministic.hpp index e025f00f55..8005757985 100644 --- a/unit_test/graph/Test_Graph_graph_color_deterministic.hpp +++ b/unit_test/graph/Test_Graph_graph_color_deterministic.hpp @@ -44,7 +44,7 @@ #include #include -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_GraphColor.hpp" #include "KokkosSparse_CrsMatrix.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_SparseUtils.hpp" From b29772b373fd9c4bdab2d43f43fd741f57264dbd Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 8 Jan 2019 14:22:12 -0700 Subject: [PATCH 086/190] D2 coloring cleanup checkpoint 2019-01-08 --- perf_test/graph/KokkosGraph_color_d2.cpp | 1167 ++++++++++------- .../graph/KokkosGraph_color_d2_wcmclen.cpp | 877 ------------- src/graph/KokkosGraph_Distance2Color.hpp | 4 +- .../KokkosGraph_Distance2GraphColorHandle.hpp | 26 + src/graph/KokkosGraph_GraphColorHandle.hpp | 1 - unit_test/graph/Test_Graph_graph_color_d2.hpp | 31 +- 6 files changed, 748 insertions(+), 1358 deletions(-) delete mode 100644 perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 3d0f2bbc6c..3386e353c1 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -2,8 +2,8 @@ //@HEADER // ************************************************************************ // -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation +// Kokkos v. 2.0 +// Copyright (2014) Sandia Corporation // // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, // the U.S. Government retains certain rights in this software. @@ -35,29 +35,36 @@ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// Questions Contact H. Carter Edwards (hcedwar@sandia.gov) // // ************************************************************************ //@HEADER */ -#include -// STL -#include +// EXERCISE 1 Goal: +// Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. +#include +#include +#include + #include +#include + +#include +#include +#include +#include +#include #include -#include // std::default_random_engine -#include // std::shuffle -#include +#include + +#include -//// Kokkos -//#include "KokkosKernels_config.h" -//#include "KokkosGraph_Distance2Color.hpp" -#include "KokkosGraph_Distance2Color.hpp" +#include +#include +#include +#include // EXPERIMENTAL (WCMCLEN) -#include "KokkosKernels_IOUtils.hpp" -#include "KokkosKernels_MyCRSMatrix.hpp" -#include "KokkosKernels_TestParameters.hpp" using namespace KokkosGraph; #ifdef KOKKOSKERNELS_INST_DOUBLE @@ -85,554 +92,786 @@ typedef int64_t kk_lno_t; #endif -void print_options(std::ostream& os, const char* app_name, unsigned int indent=0) +using namespace KokkosGraph; + + + +void print_options(std::ostream &os, const char *app_name, unsigned int indent = 0) { - std::string spaces(indent, ' '); - os << "Usage:" << std::endl - << spaces << " " << app_name << " [parameters]" << std::endl - << std::endl - << spaces << "Parameters:" << std::endl - << spaces << " Parallelism (select one of the following):" << std::endl - << spaces << " serial Execute serially." << std::endl - << spaces << " threads Use N posix threads." << std::endl - << spaces << " openmp Use OpenMP with N threads." << std::endl - << spaces << " cuda Use CUDA" << std::endl - << std::endl - << spaces << " Required Parameters:" << std::endl - << spaces << " amtx Input file in Matrix Market format (.mtx)." << std::endl - << std::endl - << spaces << " algorithm Set the algorithm to use. Allowable values are:" << std::endl - << spaces << " COLORING_D2_MATRIX_SQUARED - Distance-2 coloring using matrix-squared + Distance-1 coloring method." << std::endl - << spaces << " COLORING_D2 - Distance-2 coloring using traversal based method." << std::endl - << std::endl - << spaces << " Optional Parameters:" << std::endl - << spaces << " chunksize Set the chunk size." << std::endl - << spaces << " dynamic Use dynamic scheduling." << std::endl - << spaces << " repeat Set number of test repetitions (Default: 6) " << std::endl - << spaces << " teamsize Set the team size." << std::endl - << spaces << " vectorsize Set the vector size." << std::endl - << spaces << " verbose Enable verbose mode (print timing + extra information" << std::endl - << spaces << " help Print out command line help." << std::endl - << spaces << " " << std::endl; + std::string spaces(indent, ' '); + os << "Usage:" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl + << std::endl + << spaces << "Parameters:" << std::endl + << spaces << " Parallelism (select one of the following):" << std::endl + << spaces << " --serial Execute serially." << std::endl + << spaces << " --threads Use N posix threads." << std::endl + << spaces << " --openmp Use OpenMP with N threads." << std::endl + << spaces << " --cuda Use CUDA" << std::endl + << std::endl + << spaces << " Required Parameters:" << std::endl + << spaces << " --amtx Input file in Matrix Market format (.mtx)." << std::endl + << std::endl + << spaces << " --algorithm Set the algorithm to use. Allowable values are:" << std::endl + << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl + << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl + << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array (Default)." << std::endl + << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl + << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl + + << std::endl + << spaces << " Optional Parameters:" << std::endl + << spaces << " --repeat Set number of test repetitions (Default: 1) " << std::endl + << spaces << " --verbose Enable verbose mode (record and print timing + extra information)" << std::endl + << spaces << " --chunksize Set the chunk size." << std::endl + << spaces << " --dynamic Use dynamic scheduling." << std::endl + << spaces << " --teamsize Set the team size." << std::endl + << spaces << " --vectorsize Set the vector size." << std::endl + << spaces << " --help Print out command line help." << std::endl + << spaces << " " << std::endl; } -int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) +int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) { - bool got_required_param_amtx=false; - bool got_required_param_algorithm=false; + bool got_required_param_amtx = false; + bool got_required_param_algorithm = false; - for(int i = 1; i < argc; ++i) - { - if ( 0 == strcasecmp( argv[i] , "threads" ) ) - { - params.use_threads = atoi( argv[++i] ); - } - else if ( 0 == strcasecmp( argv[i] , "serial" ) ) - { - params.use_serial = atoi( argv[++i] ); - } - else if ( 0 == strcasecmp( argv[i] , "openmp" ) ) - { - params.use_openmp = atoi( argv[++i] ); - } - else if ( 0 == strcasecmp( argv[i] , "cuda" ) ) - { - params.use_cuda = 1; - } - else if ( 0 == strcasecmp( argv[i] , "repeat" ) ) - { - params.repeat = atoi( argv[++i] ); - } - else if ( 0 == strcasecmp( argv[i] , "chunksize" ) ) - { - params.chunk_size = atoi( argv[++i] ) ; - } - else if ( 0 == strcasecmp( argv[i] , "teamsize" ) ) + for(int i = 1; i < argc; ++i) { - params.team_size = atoi( argv[++i] ) ; - } - else if ( 0 == strcasecmp( argv[i] , "vectorsize" ) ) - { - params.vector_size = atoi( argv[++i] ) ; - } - else if ( 0 == strcasecmp( argv[i] , "amtx" ) ) - { - got_required_param_amtx = true; - params.a_mtx_bin_file = argv[++i]; - } - else if ( 0 == strcasecmp( argv[i] , "dynamic" ) ) - { - params.use_dynamic_scheduling = 1; - } - else if ( 0 == strcasecmp( argv[i] , "verbose" ) ) - { - params.verbose = 1; + if(0 == strcasecmp(argv[i], "--threads")) + { + params.use_threads = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--serial")) + { + params.use_serial = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--openmp")) + { + params.use_openmp = atoi(argv[++i]); + std::cout << "use_openmp = " << params.use_openmp << std::endl; + } + else if(0 == strcasecmp(argv[i], "--cuda")) + { + params.use_cuda = 1; + } + else if(0 == strcasecmp(argv[i], "--repeat")) + { + params.repeat = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--chunksize")) + { + params.chunk_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--teamsize")) + { + params.team_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--vectorsize")) + { + params.vector_size = atoi(argv[++i]); + } + else if(0 == strcasecmp(argv[i], "--amtx")) + { + got_required_param_amtx = true; + params.a_mtx_bin_file = argv[++i]; + } + else if(0 == strcasecmp(argv[i], "--dynamic")) + { + params.use_dynamic_scheduling = 1; + } + else if(0 == strcasecmp(argv[i], "--verbose")) + { + params.verbose = 1; + } + else if(0 == strcasecmp(argv[i], "--algorithm")) + { + ++i; + if(0 == strcasecmp(argv[i], "COLORING_D2_MATRIX_SQUARED")) + { + params.algorithm = 1; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) + { + params.algorithm = 2; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || 0 == strcasecmp(argv[i], "COLORING_D2") ) + { + params.algorithm = 3; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT")) + { + params.algorithm = 4; + got_required_param_algorithm = true; + } + else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT_EF")) + { + params.algorithm = 5; + got_required_param_algorithm = true; + } + else + { + std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; + print_options(std::cout, argv[0]); + return 1; + } + } + else if(0 == strcasecmp(argv[i], "--help") || 0 == strcasecmp(argv[i], "-h")) + { + print_options(std::cout, argv[0]); + return 1; + } + else + { + std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; + print_options(std::cout, argv[0]); + return 1; + } } - else if ( 0 == strcasecmp( argv[i] , "algorithm" ) ) + + if(!got_required_param_amtx) { - ++i; - if ( 0 == strcasecmp( argv[i] , "COLORING_D2_MATRIX_SQUARED" ) ) - { - params.algorithm = 1; - got_required_param_algorithm = true; - } - else if ( 0 == strcasecmp( argv[i], "COLORING_D2" ) ) - { - params.algorithm = 2; - got_required_param_algorithm = true; - } - else - { - std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; + std::cout << "Missing required parameter amtx" << std::endl << std::endl; print_options(std::cout, argv[0]); return 1; - } } - else if ( 0 == strcasecmp( argv[i], "help") || 0 == strcasecmp(argv[i], "-h") ) + if(!got_required_param_algorithm) { - print_options(std::cout, argv[0]); - return 1; + std::cout << "Missing required parameter algorithm" << std::endl << std::endl; + print_options(std::cout, argv[0]); + return 1; } - else + if(!params.use_serial && !params.use_threads && !params.use_openmp && !params.use_cuda) { - std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; - print_options(std::cout, argv[0]); - return 1; + print_options(std::cout, argv[0]); + return 1; } - } - - if(!got_required_param_amtx) - { - std::cout << "Missing required parameter amtx" << std::endl << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - if(!got_required_param_algorithm) - { - std::cout << "Missing required parameter algorithm" << std::endl << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - if(!params.use_serial && !params.use_threads && !params.use_openmp && !params.use_cuda) - { - print_options(std::cout, argv[0]); - return 1; - } - return 0; + return 0; } + namespace KokkosKernels { namespace Experiment { -template -void run_experiment(crsGraph_t crsGraph, Parameters params) -{ - using namespace KokkosGraph; - using namespace KokkosGraph::Experimental; - - int algorithm = params.algorithm; - int repeat = params.repeat; - int chunk_size = params.chunk_size; - int shmemsize = params.shmemsize; - int team_size = params.team_size; - int use_dynamic_scheduling = params.use_dynamic_scheduling; - int verbose = params.verbose; +std::string getCurrentDateTimeStr() +{ + // Note: This could be replaced with `std::put_time(&tm, "%FT%T%z")` but std::put_time isn't + // supported on the intel C++ compilers as of v. 17.0.x + time_t now = time(0); + char output[100]; + std::strftime(output, sizeof(output), "%FT%T%Z", std::localtime(&now)); + return output; +} - //char spgemm_step = params.spgemm_step; - int vector_size = params.vector_size; - typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; - typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; +template +void run_experiment(crsGraph_t crsGraph, Parameters params) +{ + using namespace KokkosGraph; + using namespace KokkosGraph::Experimental; - typedef typename lno_view_t::non_const_value_type size_type; - typedef typename lno_nnz_view_t::non_const_value_type lno_t; + int algorithm = params.algorithm; + int repeat = params.repeat; + int chunk_size = params.chunk_size; - typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + int shmemsize = params.shmemsize; + int team_size = params.team_size; + int use_dynamic_scheduling = params.use_dynamic_scheduling; + int verbose = params.verbose; - // Note: crsGraph.numRows() == number of vertices in the 'graph' - // crsGraph.entries.extent(0) == number of edges in the 'graph' + // char spgemm_step = params.spgemm_step; + int vector_size = params.vector_size; - std::cout << "Num verts: " << crsGraph.numRows() << std::endl - << "Num edges: " << crsGraph.entries.extent(0) << std::endl; + typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; + typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; - KernelHandle kh; - kh.set_team_work_size(chunk_size); - kh.set_shmem_size(shmemsize); - kh.set_suggested_team_size(team_size); - kh.set_suggested_vector_size(vector_size); + typedef typename lno_view_t::non_const_value_type size_type; + typedef typename lno_nnz_view_t::non_const_value_type lno_t; - if (use_dynamic_scheduling) - { - kh.set_dynamic_scheduling(true); - } + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; - if (verbose) - { - kh.set_verbose(true); - } + // Get Date/Time stamps of start to use later when printing out summary data. + //auto t = std::time(nullptr); + //auto tm = *std::localtime(&t); - // accumulators for average stats - double total_time = 0.0; - size_t total_colors = 0; - size_t total_phases = 0; + // Note: crsGraph.numRows() == number of vertices in the 'graph' + // crsGraph.entries.extent(0) == number of edges in the 'graph' + std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; - std::string label_algorithm; + KernelHandle kh; + kh.set_team_work_size(chunk_size); + kh.set_shmem_size(shmemsize); + kh.set_suggested_team_size(team_size); + kh.set_suggested_vector_size(vector_size); - for (int i = 0; i < repeat; ++i) - { + if(use_dynamic_scheduling) + { + kh.set_dynamic_scheduling(true); + } - switch (algorithm) + if(verbose) { - case 1: - // kh.create_graph_coloring_handle(COLORING_SPGEMM); - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; - break; - case 2: - kh.create_graph_coloring_handle(COLORING_D2); - label_algorithm = "COLORING_D2"; - break; - default: - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; - break; + kh.set_verbose(true); } - graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + // accumulators for average stats + size_t total_colors = 0; + size_t total_phases = 0; - std::cout << "Time : " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl - << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl - << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; - std::cout << "\t"; - KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); - std::cout << std::endl; + std::string label_algorithm; + switch(algorithm) + { + case 1: + kh.create_distance2_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); + label_algorithm = "COLORING_D2_MATRIX_SQUARED"; + break; + case 2: + kh.create_distance2_graph_coloring_handle(COLORING_D2_SERIAL); + label_algorithm = "COLORING_D2_SERIAL"; + break; + case 3: + kh.create_distance2_graph_coloring_handle(COLORING_D2_VB); + label_algorithm = "COLORING_D2_VB"; + break; + case 4: + kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT); + label_algorithm = "COLORING_D2_VB_BIT"; + break; + case 5: + kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT_EF); + label_algorithm = "COLORING_D2_VB_BIT_EF"; + break; + default: + kh.create_distance2_graph_coloring_handle(COLORING_D2_VB); + label_algorithm = "COLORING_D2_VB"; + break; + } - total_time += kh.get_graph_coloring_handle()->get_overall_coloring_time(); - total_colors += kh.get_graph_coloring_handle()->get_num_colors(); - total_phases += kh.get_graph_coloring_handle()->get_num_phases(); - } - - double avg_time = total_time / repeat; - double avg_colors = total_colors / (double)repeat; - double avg_phases = total_phases / (double)repeat; - - std::string a_mtx_bin_file = params.a_mtx_bin_file; - a_mtx_bin_file = a_mtx_bin_file.substr( a_mtx_bin_file.find_last_of("/\\")+1 ); - - std::cout << "Summary:" << std::endl - << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl - << " Filename : " << a_mtx_bin_file << std::endl - << " Num Verts : " << crsGraph.numRows() << std::endl - << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl - << " Concurrency: " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl - << " Algorithm : " << label_algorithm << std::endl - << " Avg Time : " << avg_time << std::endl - << " Avg colors : " << avg_colors << std::endl - << " Avg Phases : " << avg_phases << std::endl - << std::endl; - - std::cout << "CSV" - << "," << a_mtx_bin_file - << "," << crsGraph.numRows() - << "," << crsGraph.entries.dimension_0() - << "," << Kokkos::DefaultExecutionSpace::name() - << "," << Kokkos::DefaultExecutionSpace::concurrency() - << "," << label_algorithm - << "," << avg_time - << "," << avg_colors - << "," << avg_phases - << std::endl; - //Kokkos::print_configuration(std::cout); + std::cout << ">>> Run Graph Color D2 (" << label_algorithm << ")" << std::endl; -} + // If any of the runs have an invalid result, this will be set to false. + bool all_results_valid = true; + // Loop over # of experiments to run + for(int i = 0; i < repeat; ++i) + { + graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + total_colors += kh.get_distance2_graph_coloring_handle()->get_num_colors(); + total_phases += kh.get_distance2_graph_coloring_handle()->get_num_phases(); -template -void run_multi_mem_experiment(Parameters params) -{ + std::cout << "Total Time: " << kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time() << std::endl + << "Num colors: " << kh.get_distance2_graph_coloring_handle()->get_num_colors() << std::endl + << "Num Phases: " << kh.get_distance2_graph_coloring_handle()->get_num_phases() << std::endl; + std::cout << "\t"; + KokkosKernels::Impl::print_1Dview(kh.get_distance2_graph_coloring_handle()->get_vertex_colors()); + std::cout << std::endl; - typedef exec_space myExecSpace; - typedef Kokkos::Device myFastDevice; - typedef Kokkos::Device mySlowExecSpace; - - typedef typename MyKokkosSparse::CrsMatrix fast_crstmat_t; - typedef typename fast_crstmat_t::StaticCrsGraphType fast_graph_t; - //typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; - //typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; - - //typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; - //typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; - - typedef typename MyKokkosSparse::CrsMatrix slow_crstmat_t; - typedef typename slow_crstmat_t::StaticCrsGraphType slow_graph_t; - - //typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; - //typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; - //typedef typename slow_graph_t::row_map_type::const_type const_slow_row_map_view_t; - //typedef typename slow_graph_t::entries_type::const_type const_slow_cols_view_t; - - char *a_mat_file = params.a_mtx_bin_file; - - slow_graph_t a_slow_crsgraph, /*b_slow_crsgraph,*/ c_slow_crsgraph; - fast_graph_t a_fast_crsgraph, /*b_fast_crsgraph,*/ c_fast_crsgraph; - - //read a and b matrices and store them on slow or fast memory. - if (params.a_mem_space == 1) - { - fast_crstmat_t a_fast_crsmat; - a_fast_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); - a_fast_crsgraph = a_fast_crsmat.graph; - a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); - - } - else - { - slow_crstmat_t a_slow_crsmat; - a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); - a_slow_crsgraph = a_slow_crsmat.graph; - a_slow_crsgraph.num_cols = a_slow_crsmat.numCols(); - } - - if (params.a_mem_space == 1) - { - if (params.b_mem_space == 1) - { - if (params.c_mem_space == 1) - { - if (params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); - } - else + // If verbose mode is on and there the graph has fewer than 1000 verts, dump a GraphVIZ DOT file. + if(verbose && repeat==i+1 && crsGraph.numRows() < 1000) { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); + auto colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); + std::ofstream os("G.dot", std::ofstream::out); + kh.get_distance2_graph_coloring_handle()->graphToGraphviz(os, + crsGraph.numRows(), + crsGraph.row_map, + crsGraph.entries, + colors); } - } - else - { - //C is in slow memory. - if (params.work_mem_space == 1) + // ------------------------------------------ + // Verify correctness + // ------------------------------------------ + bool d2_coloring_is_valid = false; + bool d2_coloring_validation_flags[4] = {false}; + + d2_coloring_is_valid = verifyDistance2Coloring(&kh, + crsGraph.numRows(), + crsGraph.numCols(), + crsGraph.row_map, + crsGraph.entries, + crsGraph.row_map, + crsGraph.entries, + d2_coloring_validation_flags); + + // Print out messages based on coloring validation check. + if(d2_coloring_is_valid) { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); + std::cout << std::endl << ">>> Distance-2 Graph Coloring is VALID" << std::endl << std::endl; } else { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); + all_results_valid = false; + std::cout << std::endl + << ">>> Distance-2 Graph Coloring is NOT VALID" << std::endl + << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl + << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl + << std::endl; } - } - } - else - { - //B is in slow memory - if (params.c_mem_space == 1) - { - if (params.work_mem_space == 1) + if(d2_coloring_validation_flags[3]) { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); + std::cout << ">>> Distance-2 Graph Coloring may have poor quality." << std::endl + << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl + << std::endl; } - } - else - { - //C is in slow memory. - if (params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_fast_crsgraph, /*b_slow_crsgraph,*/ params); - } - } + // ------------------------------------------ + // Print out the colors histogram + // ------------------------------------------ + printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); + + } // for i... + + // ------------------------------------------ + // Compute Distance 2 Degree Stats + // ------------------------------------------ + std::cout << "Compute Distance-2 Degree " << std::endl; + + Kokkos::Impl::Timer timer; + +/* + double time_d2_degree; + timer.reset(); + + typedef typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; + non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); + + size_t degree_d2_max=0; + computeDistance2Degree(&kh, crsGraph.numRows(), crsGraph.numCols(), + crsGraph.row_map, crsGraph.entries, + crsGraph.row_map, crsGraph.entries, + degree_d2_dist, degree_d2_max); + time_d2_degree = timer.seconds(); +*/ + + double total_time = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time(); + double total_time_color_greedy = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase1(); + double total_time_find_conflicts = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase2(); + double total_time_resolve_conflicts = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase3(); + double total_time_matrix_squared = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase4(); + double total_time_matrix_squared_d1 = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase5(); + + double avg_time = total_time / (double)repeat; + double avg_time_color_greedy = total_time_color_greedy / (double)repeat; + double avg_time_find_conflicts = total_time_find_conflicts / (double)repeat; + double avg_time_resolve_conflicts = total_time_resolve_conflicts / (double)repeat; + double avg_colors = total_colors / (double)repeat; + double avg_phases = total_phases / (double)repeat; + double avg_time_matrix_squared = total_time_matrix_squared / (double)repeat; + double avg_time_matrix_squared_d1 = total_time_matrix_squared_d1 / (double)repeat; + + std::string a_mtx_bin_file = params.a_mtx_bin_file; + a_mtx_bin_file = a_mtx_bin_file.substr(a_mtx_bin_file.find_last_of("/\\") + 1); + + int result; + char hostname[100]; + char username[100]; + + result = gethostname(hostname, 100); + if(result) + { + perror("gethostname"); } - } - else - { - //A is in slow memory - if (params.b_mem_space == 1) + + result = getlogin_r(username, 100); + if(result) { - if (params.c_mem_space == 1) - { - if (params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); - } - } - else - { - //C is in slow memory. - if (params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_fast_crsgraph,*/ params); - } - } + perror("getlogin_r"); + } + + std::string all_results_valid_str = "PASSED"; + if(!all_results_valid) + all_results_valid_str = "FAILED"; + + std::string currentDateTimeStr = getCurrentDateTimeStr(); + + std::cout << "Summary" << std::endl + << "-------" << std::endl + //<< " Date/Time : " << currentDateTimeStr << std::endl + << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl + << " Filename : " << a_mtx_bin_file << std::endl + << " Num Verts : " << crsGraph.numRows() << std::endl + << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl + << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl + << " Algorithm : " << label_algorithm << std::endl +// << "Graph Stats" << std::endl +// << " Degree D2 Max : " << degree_d2_max << std::endl +// << " Degree D2 Time : " << time_d2_degree << std::endl + << "Overall Time/Stats" << std::endl + << " Total Time : " << total_time << std::endl + << " Avg Time : " << avg_time << std::endl + << "VB Distance[1|2] Stats " << std::endl + << " Avg Time CG : " << avg_time_color_greedy << std::endl + << " Avg Time FC : " << avg_time_find_conflicts << std::endl + << " Avg Time RC : " << avg_time_resolve_conflicts << std::endl + << "Matrix-Squared + D1 Stats" << std::endl + << " Avg Time to M^2: " << avg_time_matrix_squared << std::endl + << " Avg Time to D1 : " << avg_time_matrix_squared_d1 << std::endl + << "Coloring Stats" << std::endl + << " Avg colors : " << avg_colors << std::endl + << " Avg Phases : " << avg_phases << std::endl + << " Validation : " << all_results_valid_str << std::endl + << std::endl; + + std::cout << "CSVTIMEHDR" + << "," << "Filename" + << "," << "Host" + //<< "," << "DateTime" + << "," << "Num Rows" + << "," << "Num Edges" + << "," << "Execution Space" + << "," << "Algorithm" + << "," << "Concurrency" + << "," << "Repetitions" + << "," << "Total Time" + << "," << "Total Time to M^2" + << "," << "Total Time D1(M^2)" + << "," << "Total Time CG" + << "," << "Total Time FC" + << "," << "Total Time RC" +// << "," << "Time D2 Degree" + << "," << "Avg Colors" + << "," << "Avg Num Phases" +// << "," << "Degree D2 Max" + << "," << "Validation" + << std::endl; + + std::cout << "CSVTIMEDATA" + << "," << a_mtx_bin_file + << "," << hostname + //<< "," << currentDateTimeStr + << "," << crsGraph.numRows() + << "," << crsGraph.entries.dimension_0() + << "," << Kokkos::DefaultExecutionSpace::name() + << "," << label_algorithm + << "," << Kokkos::DefaultExecutionSpace::concurrency() + << "," << repeat + << "," << total_time + << "," << total_time_matrix_squared + << "," << total_time_matrix_squared_d1 + << "," << total_time_color_greedy + << "," << total_time_find_conflicts + << "," << total_time_resolve_conflicts +// << "," << time_d2_degree + << "," << avg_colors + << "," << avg_phases +// << "," << degree_d2_max + << "," << all_results_valid_str + << std::endl; + + std::cout << "CSVHISTHDR" + << "," << "Filename" + << "," << "Host" + //<< "," << "DateTime" + << "," << "Num Rows" + << "," << "Num Edges" + << "," << "Execution Space" + << "," << "Algorithm" + << "," << "Concurrency" + << "," << "Histogram: 1 .. N" + << std::endl; + + std::cout << "CSVHISTDATA" + << "," << a_mtx_bin_file + << "," << hostname + //<< "," << currentDateTimeStr + << "," << crsGraph.numRows() + << "," << crsGraph.entries.dimension_0() + << "," << Kokkos::DefaultExecutionSpace::name() + << "," << label_algorithm + << "," << Kokkos::DefaultExecutionSpace::concurrency() + << ","; + printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); + std::cout << std::endl; + + // Kokkos::print_configuration(std::cout); +} + + +template +void run_multi_mem_experiment(Parameters params) +{ + + typedef exec_space myExecSpace; + typedef Kokkos::Device myFastDevice; + typedef Kokkos::Device mySlowExecSpace; + + typedef typename MyKokkosSparse::CrsMatrix fast_crstmat_t; + typedef typename fast_crstmat_t::StaticCrsGraphType fast_graph_t; + // typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; + // typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; + + // typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; + // typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; + + typedef typename MyKokkosSparse::CrsMatrix slow_crstmat_t; + typedef typename slow_crstmat_t::StaticCrsGraphType slow_graph_t; + + // typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; + // typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; + // typedef typename slow_graph_t::row_map_type::const_type const_slow_row_map_view_t; + // typedef typename slow_graph_t::entries_type::const_type const_slow_cols_view_t; + + char *a_mat_file = params.a_mtx_bin_file; + + slow_graph_t a_slow_crsgraph, /*b_slow_crsgraph,*/ c_slow_crsgraph; + fast_graph_t a_fast_crsgraph, /*b_fast_crsgraph,*/ c_fast_crsgraph; + + // read a and b matrices and store them on slow or fast memory. + if(params.a_mem_space == 1) + { + fast_crstmat_t a_fast_crsmat; + a_fast_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); + a_fast_crsgraph = a_fast_crsmat.graph; + a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); } else { - //B is in slow memory - if (params.c_mem_space == 1) - { - if (params.work_mem_space == 1) + slow_crstmat_t a_slow_crsmat; + a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); + a_slow_crsgraph = a_slow_crsmat.graph; + a_slow_crsgraph.num_cols = a_slow_crsmat.numCols(); + } + + if(params.a_mem_space == 1) + { + if(params.b_mem_space == 1) { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } } else { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); + // B is in slow memory + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } } - } - else - { - //C is in slow memory. - if (params.work_mem_space == 1) + } + else + { + // A is in slow memory + if(params.b_mem_space == 1) { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_fast_crsgraph,*/ params); + } + } } else { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment - - (a_slow_crsgraph, /*b_slow_crsgraph,*/ params); + // B is in slow memory + if(params.c_mem_space == 1) + { + if(params.work_mem_space == 1) + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /* c_fast_crsgraph = */ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } + else + { + // C is in slow memory. + if(params.work_mem_space == 1) + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + else + { + /*c_slow_crsgraph =*/ + KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, + /*b_slow_crsgraph,*/ params); + } + } } - } } - } } -} -} +} // namespace Experiment +} // namespace KokkosKernels -int main (int argc, char ** argv) + +int main(int argc, char *argv[]) { - KokkosKernels::Experiment::Parameters params; + KokkosKernels::Experiment::Parameters params; - if (parse_inputs (params, argc, argv) ) - { - return 1; - } + // Override default repeats (default is 6) + params.repeat = 1; - if (params.a_mtx_bin_file == NULL) - { - std::cerr << "Provide a matrix file" << std::endl ; - return 0; - } + if(parse_inputs(params, argc, argv)) + { + return 1; + } + + if(params.a_mtx_bin_file == NULL) + { + std::cerr << "Provide a matrix file" << std::endl; + return 0; + } - std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl - << "Sizeof(size_type): " << sizeof(kk_size_type) << std::endl; + std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl + << "Sizeof(size_type): " << sizeof(kk_size_type) << std::endl; - const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads - const int device_id = 0; - Kokkos::initialize( Kokkos::InitArguments( num_threads, -1, device_id ) ); - Kokkos::print_configuration(std::cout); + const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads + const int device_id = 0; + Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); -#if defined( KOKKOS_ENABLE_OPENMP ) - if (params.use_openmp) - { + // Print out verbose information about the configuration of the run. + // Kokkos::print_configuration(std::cout); + +#if defined(KOKKOS_ENABLE_OPENMP) + if(params.use_openmp) + { #ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #else - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #endif - } + } #endif -#if defined( KOKKOS_ENABLE_CUDA ) - if (params.use_cuda) - { +#if defined(KOKKOS_ENABLE_CUDA) + if(params.use_cuda) + { #ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #else - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #endif - } + } #endif -#if defined( KOKKOS_ENABLE_SERIAL ) - if (params.use_serial) - { +#if defined(KOKKOS_ENABLE_SERIAL) + if(params.use_serial) + { #ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #else - KokkosKernels::Experiment::run_multi_mem_experiment - (params); + KokkosKernels::Experiment::run_multi_mem_experiment(params); #endif - } + } #endif - Kokkos::finalize(); + /* + // Timer products. + struct timeval begin, end; - return 0; -} + gettimeofday(&begin, NULL); + + std::cout << "Do stuff here!" << std::endl; + + gettimeofday(&end, NULL); + // Calculate time. + double time = 1.0 * (end.tv_sec - begin.tv_sec) + 1.0e-6 * (end.tv_usec - begin.tv_usec); + + std::cout << "Time: " << time << std::endl; + */ + + Kokkos::finalize(); + + return 0; +} diff --git a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp b/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp deleted file mode 100644 index 9f521b3799..0000000000 --- a/perf_test/graph/KokkosGraph_color_d2_wcmclen.cpp +++ /dev/null @@ -1,877 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// Kokkos v. 2.0 -// Copyright (2014) Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions Contact H. Carter Edwards (hcedwar@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - -// EXERCISE 1 Goal: -// Use Kokkos to parallelize the outer loop of using Kokkos::parallel_reduce. -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include -#include -#include // EXPERIMENTAL (WCMCLEN) - - -using namespace KokkosGraph; -#ifdef KOKKOSKERNELS_INST_DOUBLE -typedef double kk_scalar_t; -#else -#ifdef KOKKOSKERNELS_INST_FLOAT -typedef float kk_scalar_t; -#endif -#endif - -#ifdef KOKKOSKERNELS_INST_OFFSET_INT -typedef int kk_size_type; -#else -#ifdef KOKKOSKERNELS_INST_OFFSET_SIZE_T -typedef size_t kk_size_type; -#endif -#endif - -#ifdef KOKKOSKERNELS_INST_ORDINAL_INT -typedef int kk_lno_t; -#else -#ifdef KOKKOSKERNELS_INST_ORDINAL_INT64_T -typedef int64_t kk_lno_t; -#endif -#endif - - -using namespace KokkosGraph; - - - -void print_options(std::ostream &os, const char *app_name, unsigned int indent = 0) -{ - std::string spaces(indent, ' '); - os << "Usage:" << std::endl - << spaces << " " << app_name << " [parameters]" << std::endl - << std::endl - << spaces << "Parameters:" << std::endl - << spaces << " Parallelism (select one of the following):" << std::endl - << spaces << " --serial Execute serially." << std::endl - << spaces << " --threads Use N posix threads." << std::endl - << spaces << " --openmp Use OpenMP with N threads." << std::endl - << spaces << " --cuda Use CUDA" << std::endl - << std::endl - << spaces << " Required Parameters:" << std::endl - << spaces << " --amtx Input file in Matrix Market format (.mtx)." << std::endl - << std::endl - << spaces << " --algorithm Set the algorithm to use. Allowable values are:" << std::endl - << spaces << " COLORING_D2_MATRIX_SQUARED - Matrix-squared + Distance-1 method." << std::endl - << spaces << " COLORING_D2_SERIAL - Serial algorithm (must use with 'serial' mode)" << std::endl - << spaces << " COLORING_D2_VB - Vertex Based method using boolean forbidden array (Default)." << std::endl - << spaces << " COLORING_D2_VB_BIT - VB with Bitvector Forbidden Array" << std::endl - << spaces << " COLORING_D2_VB_BIT_EF - VB_BIT with Edge Filtering" << std::endl - - << std::endl - << spaces << " Optional Parameters:" << std::endl - << spaces << " --repeat Set number of test repetitions (Default: 1) " << std::endl - << spaces << " --verbose Enable verbose mode (record and print timing + extra information)" << std::endl - << spaces << " --chunksize Set the chunk size." << std::endl - << spaces << " --dynamic Use dynamic scheduling." << std::endl - << spaces << " --teamsize Set the team size." << std::endl - << spaces << " --vectorsize Set the vector size." << std::endl - << spaces << " --help Print out command line help." << std::endl - << spaces << " " << std::endl; -} - - -int parse_inputs(KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) -{ - bool got_required_param_amtx = false; - bool got_required_param_algorithm = false; - - for(int i = 1; i < argc; ++i) - { - if(0 == strcasecmp(argv[i], "--threads")) - { - params.use_threads = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--serial")) - { - params.use_serial = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--openmp")) - { - params.use_openmp = atoi(argv[++i]); - std::cout << "use_openmp = " << params.use_openmp << std::endl; - } - else if(0 == strcasecmp(argv[i], "--cuda")) - { - params.use_cuda = 1; - } - else if(0 == strcasecmp(argv[i], "--repeat")) - { - params.repeat = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--chunksize")) - { - params.chunk_size = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--teamsize")) - { - params.team_size = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--vectorsize")) - { - params.vector_size = atoi(argv[++i]); - } - else if(0 == strcasecmp(argv[i], "--amtx")) - { - got_required_param_amtx = true; - params.a_mtx_bin_file = argv[++i]; - } - else if(0 == strcasecmp(argv[i], "--dynamic")) - { - params.use_dynamic_scheduling = 1; - } - else if(0 == strcasecmp(argv[i], "--verbose")) - { - params.verbose = 1; - } - else if(0 == strcasecmp(argv[i], "--algorithm")) - { - ++i; - if(0 == strcasecmp(argv[i], "COLORING_D2_MATRIX_SQUARED")) - { - params.algorithm = 1; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_SERIAL")) - { - params.algorithm = 2; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VB") || 0 == strcasecmp(argv[i], "COLORING_D2") ) - { - params.algorithm = 3; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT")) - { - params.algorithm = 4; - got_required_param_algorithm = true; - } - else if(0 == strcasecmp(argv[i], "COLORING_D2_VB_BIT_EF")) - { - params.algorithm = 5; - got_required_param_algorithm = true; - } - else - { - std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - } - else if(0 == strcasecmp(argv[i], "--help") || 0 == strcasecmp(argv[i], "-h")) - { - print_options(std::cout, argv[0]); - return 1; - } - else - { - std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - } - - if(!got_required_param_amtx) - { - std::cout << "Missing required parameter amtx" << std::endl << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - if(!got_required_param_algorithm) - { - std::cout << "Missing required parameter algorithm" << std::endl << std::endl; - print_options(std::cout, argv[0]); - return 1; - } - if(!params.use_serial && !params.use_threads && !params.use_openmp && !params.use_cuda) - { - print_options(std::cout, argv[0]); - return 1; - } - return 0; -} - - -namespace KokkosKernels { -namespace Experiment { - - -std::string getCurrentDateTimeStr() -{ - // Note: This could be replaced with `std::put_time(&tm, "%FT%T%z")` but std::put_time isn't - // supported on the intel C++ compilers as of v. 17.0.x - time_t now = time(0); - char output[100]; - std::strftime(output, sizeof(output), "%FT%T%Z", std::localtime(&now)); - return output; -} - - -template -void run_experiment(crsGraph_t crsGraph, Parameters params) -{ - using namespace KokkosGraph; - using namespace KokkosGraph::Experimental; - - int algorithm = params.algorithm; - int repeat = params.repeat; - int chunk_size = params.chunk_size; - - int shmemsize = params.shmemsize; - int team_size = params.team_size; - int use_dynamic_scheduling = params.use_dynamic_scheduling; - int verbose = params.verbose; - - // char spgemm_step = params.spgemm_step; - int vector_size = params.vector_size; - - typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; - typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; - - typedef typename lno_view_t::non_const_value_type size_type; - typedef typename lno_nnz_view_t::non_const_value_type lno_t; - - typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; - - // Get Date/Time stamps of start to use later when printing out summary data. - //auto t = std::time(nullptr); - //auto tm = *std::localtime(&t); - - // Note: crsGraph.numRows() == number of vertices in the 'graph' - // crsGraph.entries.extent(0) == number of edges in the 'graph' - std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; - - KernelHandle kh; - kh.set_team_work_size(chunk_size); - kh.set_shmem_size(shmemsize); - kh.set_suggested_team_size(team_size); - kh.set_suggested_vector_size(vector_size); - - if(use_dynamic_scheduling) - { - kh.set_dynamic_scheduling(true); - } - - if(verbose) - { - kh.set_verbose(true); - } - - // accumulators for average stats - size_t total_colors = 0; - size_t total_phases = 0; - - std::string label_algorithm; - switch(algorithm) - { - case 1: - kh.create_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); - label_algorithm = "COLORING_D2_MATRIX_SQUARED"; - break; - case 2: - kh.create_graph_coloring_handle(COLORING_D2_SERIAL); - label_algorithm = "COLORING_D2_SERIAL"; - break; - case 3: - kh.create_graph_coloring_handle(COLORING_D2_VB); - label_algorithm = "COLORING_D2_VB"; - break; - case 4: - kh.create_graph_coloring_handle(COLORING_D2_VB_BIT); - label_algorithm = "COLORING_D2_VB_BIT"; - break; - case 5: - kh.create_graph_coloring_handle(COLORING_D2_VB_BIT_EF); - label_algorithm = "COLORING_D2_VB_BIT_EF"; - break; - default: - kh.create_graph_coloring_handle(COLORING_D2_VB); - label_algorithm = "COLORING_D2_VB"; - break; - } - - std::cout << ">>> Run Graph Color D2 (" << label_algorithm << ")" << std::endl; - - // If any of the runs have an invalid result, this will be set to false. - bool all_results_valid = true; - - // Loop over # of experiments to run - for(int i = 0; i < repeat; ++i) - { - - graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); - - total_colors += kh.get_graph_coloring_handle()->get_num_colors(); - total_phases += kh.get_graph_coloring_handle()->get_num_phases(); - - std::cout << "Total Time: " << kh.get_graph_coloring_handle()->get_overall_coloring_time() << std::endl - << "Num colors: " << kh.get_graph_coloring_handle()->get_num_colors() << std::endl - << "Num Phases: " << kh.get_graph_coloring_handle()->get_num_phases() << std::endl; - std::cout << "\t"; - KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors()); - std::cout << std::endl; - - // If verbose mode is on and there the graph has fewer than 1000 verts, dump a GraphVIZ DOT file. - if(verbose && repeat==i+1 && crsGraph.numRows() < 1000) - { - auto colors = kh.get_graph_coloring_handle()->get_vertex_colors(); - std::ofstream os("G.dot", std::ofstream::out); - kh.get_graph_coloring_handle()->graphToGraphviz(os, - crsGraph.numRows(), - crsGraph.row_map, - crsGraph.entries, - colors); - } - - // ------------------------------------------ - // Verify correctness - // ------------------------------------------ - bool d2_coloring_is_valid = false; - bool d2_coloring_validation_flags[4] = {false}; - - d2_coloring_is_valid = verifyDistance2Coloring(&kh, - crsGraph.numRows(), - crsGraph.numCols(), - crsGraph.row_map, - crsGraph.entries, - crsGraph.row_map, - crsGraph.entries, - d2_coloring_validation_flags); - - // Print out messages based on coloring validation check. - if(d2_coloring_is_valid) - { - std::cout << std::endl << ">>> Distance-2 Graph Coloring is VALID" << std::endl << std::endl; - } - else - { - all_results_valid = false; - std::cout << std::endl - << ">>> Distance-2 Graph Coloring is NOT VALID" << std::endl - << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl - << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl - << std::endl; - } - if(d2_coloring_validation_flags[3]) - { - std::cout << ">>> Distance-2 Graph Coloring may have poor quality." << std::endl - << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl - << std::endl; - } - - // ------------------------------------------ - // Print out the colors histogram - // ------------------------------------------ - printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); - - } // for i... - - // ------------------------------------------ - // Compute Distance 2 Degree Stats - // ------------------------------------------ - std::cout << "Compute Distance-2 Degree " << std::endl; - - double time_d2_degree; - Kokkos::Impl::Timer timer; - timer.reset(); -/* - typedef typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; - non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); - - size_t degree_d2_max=0; - computeDistance2Degree(&kh, crsGraph.numRows(), crsGraph.numCols(), - crsGraph.row_map, crsGraph.entries, - crsGraph.row_map, crsGraph.entries, - degree_d2_dist, degree_d2_max); -*/ - time_d2_degree = timer.seconds(); - - - double total_time = kh.get_graph_coloring_handle()->get_overall_coloring_time(); - double total_time_color_greedy = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase1(); - double total_time_find_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase2(); - double total_time_resolve_conflicts = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase3(); - double total_time_matrix_squared = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase4(); - double total_time_matrix_squared_d1 = kh.get_graph_coloring_handle()->get_overall_coloring_time_phase5(); - - double avg_time = total_time / (double)repeat; - double avg_time_color_greedy = total_time_color_greedy / (double)repeat; - double avg_time_find_conflicts = total_time_find_conflicts / (double)repeat; - double avg_time_resolve_conflicts = total_time_resolve_conflicts / (double)repeat; - double avg_colors = total_colors / (double)repeat; - double avg_phases = total_phases / (double)repeat; - double avg_time_matrix_squared = total_time_matrix_squared / (double)repeat; - double avg_time_matrix_squared_d1 = total_time_matrix_squared_d1 / (double)repeat; - - std::string a_mtx_bin_file = params.a_mtx_bin_file; - a_mtx_bin_file = a_mtx_bin_file.substr(a_mtx_bin_file.find_last_of("/\\") + 1); - - - int result; - char hostname[100]; - char username[100]; - - result = gethostname(hostname, 100); - if(result) - { - perror("gethostname"); - } - - result = getlogin_r(username, 100); - if(result) - { - perror("getlogin_r"); - } - - std::string all_results_valid_str = "PASSED"; - if(!all_results_valid) - all_results_valid_str = "FAILED"; - - std::string currentDateTimeStr = getCurrentDateTimeStr(); - - std::cout << "Summary" << std::endl - << "-------" << std::endl - //<< " Date/Time : " << currentDateTimeStr << std::endl - << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl - << " Filename : " << a_mtx_bin_file << std::endl - << " Num Verts : " << crsGraph.numRows() << std::endl - << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl - << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl - << " Algorithm : " << label_algorithm << std::endl - << "Graph Stats" << std::endl - << " Degree D2 Max : " << degree_d2_max << std::endl - << " Degree D2 Time : " << time_d2_degree << std::endl - << "Overall Time/Stats" << std::endl - << " Total Time : " << total_time << std::endl - << " Avg Time : " << avg_time << std::endl - << "VB Distance[1|2] Stats " << std::endl - << " Avg Time CG : " << avg_time_color_greedy << std::endl - << " Avg Time FC : " << avg_time_find_conflicts << std::endl - << " Avg Time RC : " << avg_time_resolve_conflicts << std::endl - << "Matrix-Squared + D1 Stats" << std::endl - << " Avg Time to M^2: " << avg_time_matrix_squared << std::endl - << " Avg Time to D1 : " << avg_time_matrix_squared_d1 << std::endl - << "Coloring Stats" << std::endl - << " Avg colors : " << avg_colors << std::endl - << " Avg Phases : " << avg_phases << std::endl - << " Validation : " << all_results_valid_str << std::endl - << std::endl; - - std::cout << "CSVTIMEHDR" - << "," << "Filename" - << "," << "Host" - //<< "," << "DateTime" - << "," << "Num Rows" - << "," << "Num Edges" - << "," << "Execution Space" - << "," << "Algorithm" - << "," << "Concurrency" - << "," << "Repetitions" - << "," << "Total Time" - << "," << "Total Time to M^2" - << "," << "Total Time D1(M^2)" - << "," << "Total Time CG" - << "," << "Total Time FC" - << "," << "Total Time RC" - << "," << "Time D2 Degree" - << "," << "Avg Colors" - << "," << "Avg Num Phases" - << "," << "Degree D2 Max" - << "," << "Validation" - << std::endl; - - std::cout << "CSVTIMEDATA" - << "," << a_mtx_bin_file - << "," << hostname - //<< "," << currentDateTimeStr - << "," << crsGraph.numRows() - << "," << crsGraph.entries.dimension_0() - << "," << Kokkos::DefaultExecutionSpace::name() - << "," << label_algorithm - << "," << Kokkos::DefaultExecutionSpace::concurrency() - << "," << repeat - << "," << total_time - << "," << total_time_matrix_squared - << "," << total_time_matrix_squared_d1 - << "," << total_time_color_greedy - << "," << total_time_find_conflicts - << "," << total_time_resolve_conflicts - << "," << time_d2_degree - << "," << avg_colors - << "," << avg_phases - << "," << degree_d2_max - << "," << all_results_valid_str - << std::endl; - - std::cout << "CSVHISTHDR" - << "," << "Filename" - << "," << "Host" - //<< "," << "DateTime" - << "," << "Num Rows" - << "," << "Num Edges" - << "," << "Execution Space" - << "," << "Algorithm" - << "," << "Concurrency" - << "," << "Histogram: 1 .. N" - << std::endl; - - std::cout << "CSVHISTDATA" - << "," << a_mtx_bin_file - << "," << hostname - //<< "," << currentDateTimeStr - << "," << crsGraph.numRows() - << "," << crsGraph.entries.dimension_0() - << "," << Kokkos::DefaultExecutionSpace::name() - << "," << label_algorithm - << "," << Kokkos::DefaultExecutionSpace::concurrency() - << ","; - printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); - std::cout << std::endl; - - // Kokkos::print_configuration(std::cout); -} - - -template -void run_multi_mem_experiment(Parameters params) -{ - - typedef exec_space myExecSpace; - typedef Kokkos::Device myFastDevice; - typedef Kokkos::Device mySlowExecSpace; - - typedef typename MyKokkosSparse::CrsMatrix fast_crstmat_t; - typedef typename fast_crstmat_t::StaticCrsGraphType fast_graph_t; - // typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; - // typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; - - // typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; - // typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; - - typedef typename MyKokkosSparse::CrsMatrix slow_crstmat_t; - typedef typename slow_crstmat_t::StaticCrsGraphType slow_graph_t; - - // typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; - // typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; - // typedef typename slow_graph_t::row_map_type::const_type const_slow_row_map_view_t; - // typedef typename slow_graph_t::entries_type::const_type const_slow_cols_view_t; - - char *a_mat_file = params.a_mtx_bin_file; - - slow_graph_t a_slow_crsgraph, /*b_slow_crsgraph,*/ c_slow_crsgraph; - fast_graph_t a_fast_crsgraph, /*b_fast_crsgraph,*/ c_fast_crsgraph; - - // read a and b matrices and store them on slow or fast memory. - if(params.a_mem_space == 1) - { - fast_crstmat_t a_fast_crsmat; - a_fast_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); - a_fast_crsgraph = a_fast_crsmat.graph; - a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); - } - else - { - slow_crstmat_t a_slow_crsmat; - a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); - a_slow_crsgraph = a_slow_crsmat.graph; - a_slow_crsgraph.num_cols = a_slow_crsmat.numCols(); - } - - if(params.a_mem_space == 1) - { - if(params.b_mem_space == 1) - { - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - } - else - { - // B is in slow memory - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - } - } - else - { - // A is in slow memory - if(params.b_mem_space == 1) - { - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - } - else - { - // B is in slow memory - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - } - } -} - - -} // namespace Experiment -} // namespace KokkosKernels - - - -int main(int argc, char *argv[]) -{ - KokkosKernels::Experiment::Parameters params; - - // Override default repeats (default is 6) - params.repeat = 1; - - if(parse_inputs(params, argc, argv)) - { - return 1; - } - - if(params.a_mtx_bin_file == NULL) - { - std::cerr << "Provide a matrix file" << std::endl; - return 0; - } - - std::cout << "Sizeof(kk_lno_t) : " << sizeof(kk_lno_t) << std::endl - << "Sizeof(size_type): " << sizeof(kk_size_type) << std::endl; - - const int num_threads = params.use_openmp; // Assumption is that use_openmp variable is provided as number of threads - const int device_id = 0; - Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); - - // Print out verbose information about the configuration of the run. - // Kokkos::print_configuration(std::cout); - -#if defined(KOKKOS_ENABLE_OPENMP) - if(params.use_openmp) - { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif - } -#endif - - -#if defined(KOKKOS_ENABLE_CUDA) - if(params.use_cuda) - { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif - } -#endif - - -#if defined(KOKKOS_ENABLE_SERIAL) - if(params.use_serial) - { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif - } -#endif - - /* - // Timer products. - struct timeval begin, end; - - gettimeofday(&begin, NULL); - - std::cout << "Do stuff here!" << std::endl; - - gettimeofday(&end, NULL); - - // Calculate time. - double time = 1.0 * (end.tv_sec - begin.tv_sec) + 1.0e-6 * (end.tv_usec - begin.tv_usec); - - std::cout << "Time: " << time << std::endl; - */ - - Kokkos::finalize(); - - return 0; -} diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 97ae3e482a..fd1f982e90 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -102,8 +102,10 @@ void graph_color_d2(KernelHandle *handle, { #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; + Impl::GraphColor gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); + gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); // Save out the number of phases and vertex colors @@ -121,7 +123,7 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_VB_BIT_EF: { Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); gc.execute(); break; } diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp index 739865fe83..a33a793642 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -248,6 +248,32 @@ class Distance2GraphColoringHandle } + struct ReduceMaxFunctor + { + color_view_t colors; + ReduceMaxFunctor(color_view_t cat) : colors(cat) {} + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t& i, color_t& color_max) const + { + if(color_max < colors(i)) + color_max = colors(i); + } + + // max -plus semiring equivalent of "plus" + KOKKOS_INLINE_FUNCTION + void join(volatile color_t& dst, const volatile color_t& src) const + { + if(dst < src) + { + dst = src; + } + } + + KOKKOS_INLINE_FUNCTION + void init(color_t& dst) const { dst = 0; } + }; + nnz_lno_t get_num_colors() { diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 8c6422e5ea..febe0afdd1 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -606,7 +606,6 @@ class GraphColoringHandle }; - nnz_lno_t get_num_colors(){ if (num_colors == 0){ typedef typename Kokkos::RangePolicy my_exec_space; diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_d2.hpp index e95c004758..39bb76cdb8 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_d2.hpp @@ -102,9 +102,12 @@ run_graphcolor_d2(crsMat_t input_mat.graph.row_map, input_mat.graph.entries); - num_colors = kh.get_graph_coloring_handle()->get_num_colors(); - vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors(); - kh.destroy_graph_coloring_handle(); +// num_colors = kh.get_graph_coloring_handle()->get_num_colors(); // WCMCLEN +// vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors(); // WCMCLEN +// kh.destroy_graph_coloring_handle(); // WCMCLEN + num_colors = kh.get_distance2_graph_coloring_handle()->get_num_colors(); + vertex_colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); + kh.destroy_distance2_graph_coloring_handle(); return 0; } @@ -117,19 +120,16 @@ void test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_variance) { using namespace Test; + typedef typename KokkosSparse::CrsMatrix crsMat_t; typedef typename crsMat_t::StaticCrsGraphType graph_t; typedef typename graph_t::row_map_type lno_view_t; typedef typename graph_t::entries_type lno_nnz_view_t; - typedef typename graph_t::entries_type::non_const_type color_view_t; typedef typename crsMat_t::values_type::non_const_type scalar_view_t; - // typedef typename lno_view_t::non_const_value_type size_type; - - +// typedef typename graph_t::entries_type::non_const_type color_view_t; lno_t numCols = numRows; - crsMat_t input_mat = - KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); + crsMat_t input_mat = KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); typename lno_view_t::non_const_type sym_xadj; typename lno_nnz_view_t::non_const_type sym_adj; @@ -140,6 +140,7 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v typename lno_nnz_view_t::non_const_type, device>( numRows, input_mat.graph.row_map, input_mat.graph.entries, sym_xadj, sym_adj); + size_type numentries = sym_adj.extent(0); scalar_view_t newValues("vals", numentries); @@ -159,6 +160,7 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v std::string algName = "SPGEMM_KK_MEMSPEED"; cp.create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); typename graph_t::row_map_type::non_const_type cRowptrs("cRowptrs", numRows + 1); + // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) KokkosSparse::Experimental::spgemm_symbolic(&cp, numRows, @@ -173,12 +175,15 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v cRowptrs); // Get num nz in C auto Cnnz = cp.get_spgemm_handle()->get_c_nnz(); + // Must create placeholder value views for A and C (values are meaningless) // Said above that the scalar view type is the same as the colinds view type scalar_view_t aFakeValues("A/B placeholder values (meaningless)", input_mat.graph.entries.size()); + // Allocate C entries array, and placeholder values typename graph_t::entries_type::non_const_type cColinds("C colinds", Cnnz); scalar_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + // Run the numeric kernel KokkosSparse::Experimental::spgemm_numeric(&cp, numRows, @@ -198,6 +203,7 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v // done with spgemm cp.destroy_spgemm_handle(); +#if 0 // WCMCLEN SCAFFOLDING (RE-Enable this once the error is fixed for the perf_test example) GraphColoringAlgorithmDistance2 coloring_algorithms[] = { COLORING_D2_MATRIX_SQUARED, COLORING_D2_SERIAL, COLORING_D2, @@ -209,29 +215,23 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v for(int ii = 0; ii < num_algorithms; ++ii) { - GraphColoringAlgorithmDistance2 coloring_algorithm = coloring_algorithms[ ii ]; color_view_t vector_colors; size_t num_colors; - Kokkos::Impl::Timer timer1; crsMat_t output_mat; int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); // double coloring_time = timer1.seconds(); EXPECT_TRUE((res == 0)); - const lno_t num_rows_1 = input_mat.numRows(); const lno_t num_cols_1 = input_mat.numCols(); - - lno_t num_conflict = KokkosKernels::Impl:: kk_is_d1_coloring_valid( num_rows_1, num_cols_1, cRowptrs, cColinds, vector_colors); - lno_t conf = 0; { // also check the correctness of the validation code :) @@ -270,6 +270,7 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v EXPECT_STREQ("something", capturedStdout.c_str()); */ } + #endif // device::execution_space::finalize(); From c75bc2791a8007d1745dbaae2e55a1f8d81613a0 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 15 Jan 2019 12:55:18 -0700 Subject: [PATCH 087/190] D2 Coloring Cleanup - Compiles but segfaults --- perf_test/graph/KokkosGraph_color_d2.cpp | 51 +++++++++------ src/common/KokkosKernels_Handle.hpp | 1 + src/graph/KokkosGraph_Distance2Color.hpp | 65 +++++++++++-------- .../KokkosGraph_Distance2GraphColorHandle.hpp | 36 ++++++---- .../impl/KokkosGraph_Distance2Color_impl.hpp | 33 +++++----- 5 files changed, 112 insertions(+), 74 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 3386e353c1..873c47086e 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -67,28 +67,29 @@ using namespace KokkosGraph; + #ifdef KOKKOSKERNELS_INST_DOUBLE -typedef double kk_scalar_t; + typedef double kk_scalar_t; #else -#ifdef KOKKOSKERNELS_INST_FLOAT -typedef float kk_scalar_t; -#endif + #ifdef KOKKOSKERNELS_INST_FLOAT + typedef float kk_scalar_t; + #endif #endif #ifdef KOKKOSKERNELS_INST_OFFSET_INT -typedef int kk_size_type; + typedef int kk_size_type; #else -#ifdef KOKKOSKERNELS_INST_OFFSET_SIZE_T -typedef size_t kk_size_type; -#endif + #ifdef KOKKOSKERNELS_INST_OFFSET_SIZE_T + typedef size_t kk_size_type; + #endif #endif #ifdef KOKKOSKERNELS_INST_ORDINAL_INT -typedef int kk_lno_t; + typedef int kk_lno_t; #else -#ifdef KOKKOSKERNELS_INST_ORDINAL_INT64_T -typedef int64_t kk_lno_t; -#endif + #ifdef KOKKOSKERNELS_INST_ORDINAL_INT64_T + typedef int64_t kk_lno_t; + #endif #endif @@ -326,6 +327,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::string label_algorithm; switch(algorithm) { +#if 0 // WCMCLEN SCAFFOLDING case 1: kh.create_distance2_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; @@ -342,6 +344,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT); label_algorithm = "COLORING_D2_VB_BIT"; break; +#endif case 5: kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT_EF); label_algorithm = "COLORING_D2_VB_BIT_EF"; @@ -360,7 +363,13 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { - graph_color_d2(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); + graph_color_d2(&kh, + crsGraph.numRows(), + crsGraph.numCols(), + crsGraph.row_map, + crsGraph.entries, + crsGraph.row_map, + crsGraph.entries); total_colors += kh.get_distance2_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_distance2_graph_coloring_handle()->get_num_phases(); @@ -378,15 +387,16 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) auto colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); std::ofstream os("G.dot", std::ofstream::out); kh.get_distance2_graph_coloring_handle()->graphToGraphviz(os, - crsGraph.numRows(), - crsGraph.row_map, - crsGraph.entries, - colors); + crsGraph.numRows(), + crsGraph.row_map, + crsGraph.entries, + colors); } // ------------------------------------------ // Verify correctness // ------------------------------------------ +#if 0 bool d2_coloring_is_valid = false; bool d2_coloring_validation_flags[4] = {false}; @@ -419,11 +429,14 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl << std::endl; } +#endif // ------------------------------------------ // Print out the colors histogram // ------------------------------------------ +#if 0 printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); +#endif } // for i... @@ -434,7 +447,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) Kokkos::Impl::Timer timer; -/* +#if 0 double time_d2_degree; timer.reset(); @@ -447,7 +460,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) crsGraph.row_map, crsGraph.entries, degree_d2_dist, degree_d2_max); time_d2_degree = timer.seconds(); -*/ +#endif double total_time = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time(); double total_time_color_greedy = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase1(); diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 4c753be8fe..ddf498514c 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -437,6 +437,7 @@ class KokkosKernelsHandle this->gcHandle_d2 = new Distance2GraphColoringHandleType(); this->gcHandle_d2->set_algorithm(coloring_type, true); this->gcHandle_d2->set_tictoc(KKVERBOSE); + this->gcHandle_d2->set_verbose(KKVERBOSE); } void destroy_distance2_graph_coloring_handle() { diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index fd1f982e90..3ec35e56ea 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -43,10 +43,10 @@ #ifndef _KOKKOS_GRAPH_COLORD2_HPP #define _KOKKOS_GRAPH_COLORD2_HPP -#include "KokkosGraph_GraphColor_impl.hpp" +#include "KokkosGraph_GraphColor_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this +#include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosGraph_Distance2GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" @@ -74,10 +74,10 @@ void graph_color_d2(KernelHandle *handle, // Set our handle pointer to a GraphColoringHandleType. typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); - typename KernelHandle::Distance2GraphColoringHandleType *gch = handle->get_distance2_graph_coloring_handle(); + typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); // Get the algorithm we're running from the graph coloring handle. - GraphColoringAlgorithmDistance2 algorithm = gch->get_coloring_algo_type(); + GraphColoringAlgorithmDistance2 algorithm = gch_d2->get_coloring_algo_type(); // Create a view to save the colors to. // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) @@ -86,7 +86,7 @@ void graph_color_d2(KernelHandle *handle, typedef typename KernelHandle::Distance2GraphColoringHandleType::color_view_t color_view_type; color_view_type colors_out("Graph Colors", num_rows); - gch->set_tictoc(handle->get_verbose()); + gch_d2->set_tictoc(handle->get_verbose()); switch(algorithm) { @@ -97,7 +97,7 @@ void graph_color_d2(KernelHandle *handle, gc.execute(); break; } - +#if 1 // WCMCLEN SCAFFOLDING (the original d2 coloring in serial is in the GraphColor handle :/ ) case COLORING_D2_SERIAL: { #if defined KOKKOS_ENABLE_SERIAL @@ -109,21 +109,26 @@ void graph_color_d2(KernelHandle *handle, gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); // Save out the number of phases and vertex colors - gch->set_vertex_colors(colors_out); - gch->set_num_phases((double)num_phases); + gch_d1->set_vertex_colors(colors_out); + gch_d1->set_num_phases((double)num_phases); #else throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); #endif break; } +#endif + case COLORING_D2: case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: { - Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + + // static_assert( std::is_same< HandleType, KokkosGraph::Distance2GraphColoringHandleType>::value, “HandleType is not the correct type for this graph”); + + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); gc.execute(); break; } @@ -135,8 +140,8 @@ void graph_color_d2(KernelHandle *handle, } double coloring_time = timer.seconds(); - gch->add_to_overall_coloring_time(coloring_time); - gch->set_coloring_time(coloring_time); + gch_d2->add_to_overall_coloring_time(coloring_time); + gch_d2->set_coloring_time(coloring_time); } @@ -166,17 +171,19 @@ void graph_color_d2(KernelHandle *handle, */ template void computeDistance2Degree(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, - size_t& degree_d2_max) + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, + size_t& degree_d2_max) { - Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); gc.calculate_d2_degree(degree_d2_dist, degree_d2_max); } @@ -209,12 +216,12 @@ bool verifyDistance2Coloring(KernelHandle *handle, { bool output = true; - typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); + typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch->get_vertex_colors(), validation_flags); + output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); return output; } @@ -234,8 +241,10 @@ void printDistance2ColorsHistogram(KernelHandle *handle, lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries, bool csv=false) { - Impl::GraphColorD2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + + Impl::GraphColorD2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); if(csv) { diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp index a33a793642..10507dd78c 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -113,6 +113,7 @@ class Distance2GraphColoringHandle // Parameters GraphColoringAlgorithmDistance2 coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. + bool verbose; // verbosity flag bool tictoc; // print time at every step bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. @@ -149,6 +150,7 @@ class Distance2GraphColoringHandle */ Distance2GraphColoringHandle() : coloring_algorithm_type(COLORING_D2_DEFAULT) + , verbose(false) , tictoc(false) , vb_edge_filtering(false) , vb_chunk_size(8) @@ -318,6 +320,7 @@ class Distance2GraphColoringHandle // getters and setters GraphColoringAlgorithmDistance2 get_coloring_algo_type() const { return this->coloring_algorithm_type; } + bool get_verbose() const { return this->verbose; } double get_coloring_time() const { return this->coloring_time; } int get_max_number_of_iterations() const { return this->max_number_of_iterations; } int get_num_phases() const { return this->num_phases; } @@ -342,6 +345,7 @@ class Distance2GraphColoringHandle // setters void set_coloring_algo_type(const GraphColoringAlgorithmDistance2 &col_algo) { this->coloring_algorithm_type = col_algo; } + void set_verbose(const bool verbose_) { this->verbose = verbose_; } void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } void set_max_number_of_iterations(const int &max_phases) { this->max_number_of_iterations = max_phases; } void set_num_phases(const double &num_phases_) { this->num_phases = num_phases_; } @@ -366,6 +370,7 @@ class Distance2GraphColoringHandle this->num_colors = 0; } + // Print / write out the graph in a GraphVIZ format. // Color "1" will be rendered as a red circle. // Color "0" (uncolored) will be a star shape. @@ -374,23 +379,30 @@ class Distance2GraphColoringHandle // @param os use std::cout for output to STDOUT stream, or a ofstream object // (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write // to a file. - template - void graphToGraphviz(std::ostream &os, const index_t num_verts, rowmap_t &rowmap, entries_t &entries, kokkos_view_t &colors) const + template + void graphToGraphviz(std::ostream& os, + const size_t num_verts, + rowmap_type& rowmap, + entries_type& entries, + kokkos_view_type& colors) const { - typedef typename kokkos_view_t::HostMirror h_colors_t; - typedef typename rowmap_t::HostMirror h_rowmap_t; - typedef typename entries_t::HostMirror h_entries_t; + // typedef typename kokkos_view_t::HostMirror h_colors_t; // SCAFFOLDING + // typedef typename rowmap_t::HostMirror h_rowmap_t; // SCAFFOLDING + // typedef typename entries_t::HostMirror h_entries_t; // SCAFFOLDING + + using h_colors_type = typename kokkos_view_type::HostMirror; + using h_rowmap_type = typename rowmap_type::HostMirror; + using h_entries_type = typename entries_type::HostMirror; - h_colors_t h_colors = Kokkos::create_mirror_view(colors); + h_colors_type h_colors = Kokkos::create_mirror_view(colors); Kokkos::deep_copy(h_colors, colors); - h_rowmap_t h_rowmap = Kokkos::create_mirror_view(rowmap); + h_rowmap_type h_rowmap = Kokkos::create_mirror_view(rowmap); Kokkos::deep_copy(h_rowmap, rowmap); - h_entries_t h_entries = Kokkos::create_mirror_view(entries); + h_entries_type h_entries = Kokkos::create_mirror_view(entries); Kokkos::deep_copy(h_entries, entries); - os << "Graph G" << std::endl << "{" << std::endl << " rankdir=LR;" << std::endl @@ -401,7 +413,7 @@ class Distance2GraphColoringHandle << " edge [len=2.0];" << std::endl << std::endl; - for(index_t vid = 0; vid < num_verts; vid++) + for(size_t vid = 0; vid < num_verts; vid++) { if(1 == h_colors(vid)) { @@ -415,9 +427,9 @@ class Distance2GraphColoringHandle { os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; } - for(index_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) + for(size_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) { - index_t vadj = h_entries(iadj); + size_t vadj = h_entries(iadj); if(vadj >= vid) { os << " " << vid << " -- " << vadj << ";" << std::endl; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 314eaf8110..dceaac70af 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -82,23 +82,26 @@ namespace Impl { template class GraphColorD2 { + // TODO: after fixing the handle type, set this static assert to do the check. + // static_assert( std::is_same< HandleType, Distance2GraphColoringHandleType>::value, “HandleType is not the correct type for this graph”); + public: typedef lno_row_view_t_ in_lno_row_view_t; typedef lno_nnz_view_t_ in_lno_nnz_view_t; - typedef typename HandleType::Distance2GraphColoringHandleType::color_view_t color_view_type; - typedef typename HandleType::Distance2GraphColoringHandleType::color_t color_t; + typedef typename HandleType::color_view_t color_view_type; + typedef typename HandleType::color_t color_t; - typedef typename HandleType::Distance2GraphColoringHandleType::size_type size_type; - typedef typename HandleType::Distance2GraphColoringHandleType::nnz_lno_t nnz_lno_t; + typedef typename HandleType::size_type size_type; + typedef typename HandleType::nnz_lno_t nnz_lno_t; typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type - typedef typename HandleType::Distance2GraphColoringHandleType::color_host_view_t color_host_view_t; // host view type + typedef typename HandleType::color_host_view_t color_host_view_t; // host view type - typedef typename HandleType::Distance2GraphColoringHandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::Distance2GraphColoringHandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::Distance2GraphColoringHandleType::const_size_type const_size_type; + typedef typename HandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; + typedef typename HandleType::const_size_type const_size_type; typedef typename lno_row_view_t_::device_type row_lno_view_device_t; typedef typename lno_row_view_t_::const_type const_lno_row_view_t; @@ -109,7 +112,7 @@ class GraphColorD2 typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - typedef typename HandleType::Distance2GraphColoringHandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; typedef typename Kokkos::View single_dim_index_view_type; typedef Kokkos::RangePolicy my_exec_space; @@ -119,7 +122,7 @@ class GraphColorD2 typedef Kokkos::View non_const_1d_bool_view_t; - typedef typename HandleType::Distance2GraphColoringHandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; + typedef typename HandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; // For HashmapAccumulator typedef typename KokkosKernels::Impl::UniformMemoryPool pool_memory_space_t; // EXPERIMENTAL @@ -137,7 +140,7 @@ class GraphColorD2 const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap const_clno_nnz_view_t t_adj; // entries, transpose of entries - typename HandleType::Distance2GraphColoringHandleType *gc_handle; // pointer to the graph coloring handle + HandleType * gc_handle; // pointer to the graph coloring handle private: @@ -175,9 +178,9 @@ class GraphColorD2 , adj(entries) , t_xadj(t_row_map) , t_adj(t_entries) - , gc_handle(handle->get_graph_coloring_handle()) - , _chunkSize(handle->get_graph_coloring_handle()->get_vb_chunk_size()) - , _max_num_iterations(handle->get_graph_coloring_handle()->get_max_number_of_iterations()) + , gc_handle(handle) + , _chunkSize(handle->get_vb_chunk_size()) + , _max_num_iterations(handle->get_max_number_of_iterations()) , _use_color_set(0) , _ticToc(handle->get_verbose()) { @@ -587,7 +590,7 @@ class GraphColorD2 void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) { MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); } From 8692b0ce9831839a3337cabe41a87bb2bbf5503e Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 15 Jan 2019 15:59:21 -0700 Subject: [PATCH 088/190] D2-Coloring Cleanup Update --- perf_test/graph/KokkosGraph_color_d2.cpp | 36 +++++++++---------- unit_test/graph/Test_Graph_graph_color_d2.hpp | 33 +++++++---------- 2 files changed, 30 insertions(+), 39 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 873c47086e..4cd9b4c563 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -288,11 +288,15 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // char spgemm_step = params.spgemm_step; int vector_size = params.vector_size; - typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; - typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; + using lno_view_t = typename crsGraph_t3::row_map_type::non_const_type; + using lno_nnz_view_t = typename crsGraph_t3::entries_type::non_const_type; + // typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; + // typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; - typedef typename lno_view_t::non_const_value_type size_type; - typedef typename lno_nnz_view_t::non_const_value_type lno_t; + using size_type = typename lno_view_t::non_const_value_type; + using lno_t = typename lno_nnz_view_t::non_const_value_type; + // typedef typename lno_view_t::non_const_value_type size_type; + // typedef typename lno_nnz_view_t::non_const_value_type lno_t; typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; @@ -327,7 +331,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::string label_algorithm; switch(algorithm) { -#if 0 // WCMCLEN SCAFFOLDING case 1: kh.create_distance2_graph_coloring_handle(COLORING_D2_MATRIX_SQUARED); label_algorithm = "COLORING_D2_MATRIX_SQUARED"; @@ -344,7 +347,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT); label_algorithm = "COLORING_D2_VB_BIT"; break; -#endif case 5: kh.create_distance2_graph_coloring_handle(COLORING_D2_VB_BIT_EF); label_algorithm = "COLORING_D2_VB_BIT_EF"; @@ -396,7 +398,6 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // ------------------------------------------ // Verify correctness // ------------------------------------------ -#if 0 bool d2_coloring_is_valid = false; bool d2_coloring_validation_flags[4] = {false}; @@ -429,14 +430,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl << std::endl; } -#endif // ------------------------------------------ // Print out the colors histogram // ------------------------------------------ -#if 0 printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); -#endif } // for i... @@ -447,7 +445,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) Kokkos::Impl::Timer timer; -#if 0 + #if 0 double time_d2_degree; timer.reset(); @@ -460,7 +458,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) crsGraph.row_map, crsGraph.entries, degree_d2_dist, degree_d2_max); time_d2_degree = timer.seconds(); -#endif + #endif double total_time = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time(); double total_time_color_greedy = kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time_phase1(); @@ -513,9 +511,9 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl << " Algorithm : " << label_algorithm << std::endl -// << "Graph Stats" << std::endl -// << " Degree D2 Max : " << degree_d2_max << std::endl -// << " Degree D2 Time : " << time_d2_degree << std::endl + // << "Graph Stats" << std::endl + // << " Degree D2 Max : " << degree_d2_max << std::endl + // << " Degree D2 Time : " << time_d2_degree << std::endl << "Overall Time/Stats" << std::endl << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl @@ -548,10 +546,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Total Time CG" << "," << "Total Time FC" << "," << "Total Time RC" -// << "," << "Time D2 Degree" + // << "," << "Time D2 Degree" << "," << "Avg Colors" << "," << "Avg Num Phases" -// << "," << "Degree D2 Max" + // << "," << "Degree D2 Max" << "," << "Validation" << std::endl; @@ -571,10 +569,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << total_time_color_greedy << "," << total_time_find_conflicts << "," << total_time_resolve_conflicts -// << "," << time_d2_degree + // << "," << time_d2_degree << "," << avg_colors << "," << avg_phases -// << "," << degree_d2_max + // << "," << degree_d2_max << "," << all_results_valid_str << std::endl; diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_d2.hpp index 39bb76cdb8..0ae0b073dc 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_d2.hpp @@ -67,23 +67,17 @@ run_graphcolor_d2(crsMat_t size_t& num_colors, typename crsMat_t::StaticCrsGraphType::entries_type::non_const_type& vertex_colors) { - typedef typename crsMat_t::StaticCrsGraphType graph_t; - typedef typename graph_t::row_map_type lno_view_t; - typedef typename graph_t::entries_type lno_nnz_view_t; - typedef typename crsMat_t::values_type::non_const_type scalar_view_t; - typedef typename lno_view_t::value_type size_type; - typedef typename lno_nnz_view_t::value_type lno_t; - typedef typename scalar_view_t::value_type scalar_t; + using graph_t = typename crsMat_t::StaticCrsGraphType; + using lno_view_t = typename graph_t::row_map_type; + using lno_nnz_view_t = typename graph_t::entries_type; + using scalar_view_t = typename crsMat_t::values_type::non_const_type; + using size_type = typename lno_view_t::value_type; + using lno_t = typename lno_nnz_view_t::value_type; + using scalar_t = typename scalar_view_t::value_type; - typedef KokkosKernelsHandle - KernelHandle; + using KernelHandle = KokkosKernelsHandle; KernelHandle kh; kh.set_team_work_size(16); @@ -121,12 +115,11 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v { using namespace Test; - typedef typename KokkosSparse::CrsMatrix crsMat_t; - typedef typename crsMat_t::StaticCrsGraphType graph_t; - typedef typename graph_t::row_map_type lno_view_t; - typedef typename graph_t::entries_type lno_nnz_view_t; - typedef typename crsMat_t::values_type::non_const_type scalar_view_t; -// typedef typename graph_t::entries_type::non_const_type color_view_t; + using crsMat_t = KokkosSparse::CrsMatrix; + using graph_t = typename crsMat_t::StaticCrsGraphType; + using lno_view_t = typename graph_t::row_map_type; + using lno_nnz_view_t = typename graph_t::entries_type; + using scalar_view_t = typename crsMat_t::values_type::non_const_type; lno_t numCols = numRows; crsMat_t input_mat = KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); From 3fcf40f7296978dbd6d8e8f84514df11731b7484 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 15 Jan 2019 17:29:39 -0700 Subject: [PATCH 089/190] D2 Coloring Checkpoint --- perf_test/graph/KokkosGraph_color_d2.cpp | 7 +-- src/graph/KokkosGraph_Distance2Color.hpp | 22 ++++----- .../impl/KokkosGraph_Distance2Color_impl.hpp | 45 ++++++++++--------- 3 files changed, 36 insertions(+), 38 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 4cd9b4c563..fd7e2ce9bb 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -290,13 +290,9 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) using lno_view_t = typename crsGraph_t3::row_map_type::non_const_type; using lno_nnz_view_t = typename crsGraph_t3::entries_type::non_const_type; - // typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t; - // typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t; using size_type = typename lno_view_t::non_const_value_type; using lno_t = typename lno_nnz_view_t::non_const_value_type; - // typedef typename lno_view_t::non_const_value_type size_type; - // typedef typename lno_nnz_view_t::non_const_value_type lno_t; typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; @@ -306,7 +302,8 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Note: crsGraph.numRows() == number of vertices in the 'graph' // crsGraph.entries.extent(0) == number of edges in the 'graph' - std::cout << "Num verts: " << crsGraph.numRows() << std::endl << "Num edges: " << crsGraph.entries.extent(0) << std::endl; + std::cout << "Num verts: " << crsGraph.numRows() << std::endl + << "Num edges: " << crsGraph.entries.extent(0) << std::endl; KernelHandle kh; kh.set_team_work_size(chunk_size); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 3ec35e56ea..518ee5b908 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -73,7 +73,6 @@ void graph_color_d2(KernelHandle *handle, Kokkos::Impl::Timer timer; // Set our handle pointer to a GraphColoringHandleType. - typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); // Get the algorithm we're running from the graph coloring handle. @@ -82,29 +81,30 @@ void graph_color_d2(KernelHandle *handle, // Create a view to save the colors to. // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) // a 1D array of color_t -// typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; - typedef typename KernelHandle::Distance2GraphColoringHandleType::color_view_t color_view_type; - color_view_type colors_out("Graph Colors", num_rows); - gch_d2->set_tictoc(handle->get_verbose()); + using color_view_type = typename KernelHandle::Distance2GraphColoringHandleType::color_view_t; + + color_view_type colors_out("Graph Colors", num_rows); switch(algorithm) { case COLORING_D2_MATRIX_SQUARED: { Impl::GraphColorD2_MatrixSquared - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); gc.execute(); break; } -#if 1 // WCMCLEN SCAFFOLDING (the original d2 coloring in serial is in the GraphColor handle :/ ) + #if 1 // WCMCLEN SCAFFOLDING (the original d2 coloring in serial is in the GraphColor handle :/ ) case COLORING_D2_SERIAL: { #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; + typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); + Impl::GraphColor - gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); @@ -116,17 +116,13 @@ void graph_color_d2(KernelHandle *handle, #endif break; } -#endif - + #endif case COLORING_D2: case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: { - - // static_assert( std::is_same< HandleType, KokkosGraph::Distance2GraphColoringHandleType>::value, “HandleType is not the correct type for this graph”); - Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); gc.execute(); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index dceaac70af..4cca060d5a 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -82,8 +82,7 @@ namespace Impl { template class GraphColorD2 { - // TODO: after fixing the handle type, set this static assert to do the check. - // static_assert( std::is_same< HandleType, Distance2GraphColoringHandleType>::value, “HandleType is not the correct type for this graph”); + // static_assert( std::is_same< HandleType, KokkosGraph::Distance2GraphColoringHandle>::value, "Incorrect HandleType for this class."); public: typedef lno_row_view_t_ in_lno_row_view_t; @@ -95,8 +94,8 @@ class GraphColorD2 typedef typename HandleType::size_type size_type; typedef typename HandleType::nnz_lno_t nnz_lno_t; - typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type - typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type + typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type + typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type typedef typename HandleType::color_host_view_t color_host_view_t; // host view type typedef typename HandleType::HandleExecSpace MyExecSpace; @@ -149,6 +148,7 @@ class GraphColorD2 int _max_num_iterations; char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). bool _ticToc; // if true print info in each step + bool _verbose; // if true, print verbose information public: @@ -183,6 +183,7 @@ class GraphColorD2 , _max_num_iterations(handle->get_max_number_of_iterations()) , _use_color_set(0) , _ticToc(handle->get_verbose()) + , _verbose(handle->get_verbose()) { } @@ -202,18 +203,15 @@ class GraphColorD2 // ----------------------------------------------------------------- virtual void execute() { - bool using_edge_filtering = false; + std::cout << ">>> GraphColorD2::execute()" << std::endl; color_view_type colors_out("Graph Colors", this->nv); // If the selected pass is using edge filtering we should set the flag. - switch(this->gc_handle->get_coloring_algo_type()) + bool using_edge_filtering = false; + if(COLORING_D2_VB_BIT_EF == this->gc_handle->get_coloring_algo_type()) { - case COLORING_D2_VB_BIT_EF: - using_edge_filtering = true; - break; - default: - break; + using_edge_filtering = true; } // Data: @@ -234,12 +232,16 @@ class GraphColorD2 << "\tgraph information:" << std::endl << "\t nv : " << this->nv << std::endl << "\t ne : " << this->ne << std::endl; - - // prettyPrint1DView(this->xadj, ">>> xadj ", 500); - // prettyPrint1DView(this->adj, ">>> adj ", 500); + /* + // For extra verbosity if debugging... + prettyPrint1DView(this->xadj, ">>> xadj ", 500); + prettyPrint1DView(this->adj, ">>> adj ", 500); + prettyPrint1DView(this->t_xadj, ">>> t_xadj ", 500); + prettyPrint1DView(this->t_adj, ">>> t_adj ", 500); + */ } - #if 0 + #if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation // Compute Distance-2 Degree of the vertices. // -- Keeping this around in case we need to use it later on as an example. size_t degree_d2_max=0; @@ -298,6 +300,7 @@ class GraphColorD2 t_adj_copy = non_const_clno_nnz_view_t(Kokkos::ViewAllocateWithoutInitializing("t_adj copy"), this->ne); Kokkos::deep_copy(t_adj_copy, this->t_adj); + // Debugging //prettyPrint1DView(t_adj_copy, "t_adj_copy", 100); //prettyPrint1DView(t_adj, "t_adj", 100); @@ -501,7 +504,7 @@ class GraphColorD2 * @param degree_d2_sum : Saves the sum of the distance-2 degrees * of all vertices. * - * EXPERIMENTAL / SCAFFOLDING / WCMCLEN / + * @note This is EXPERIMENTAL */ void calculate_d2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) { @@ -529,22 +532,24 @@ class GraphColorD2 mem_chunk_size += max_nonzeros; // For hash nexts mem_chunk_size += max_nonzeros; // For hash keys // nnz_lno_t mem_chunk_size += max_nonzeros; // For hash_values -/* + + /* std::cout << "num_verts = " << this->nv << std::endl; std::cout << "v_chunk_size = " << v_chunk_size << std::endl; std::cout << "v_num_chunks = " << v_num_chunks << std::endl; std::cout << "max_d1_degree = " << max_d1_degree << std::endl; std::cout << "mem_chunk_size = " << mem_chunk_size << std::endl; std::cout << "hash_size = " << hash_size << std::endl; -*/ + */ + // HashmapAccumulator requires a memory Pool KokkosKernels::Impl::PoolType my_pool_type = KokkosKernels::Impl::OneThread2OneChunk; pool_memory_space_t m_space(v_num_chunks, mem_chunk_size, -1, my_pool_type); -/* + /* std::cout << std::endl << "Memory Pool:" << std::endl; m_space.print_memory_pool(true); -*/ + */ functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, v_chunk_size, degree_d2, m_space, hash_size, max_nonzeros); Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, v_num_chunks), calculateD2Degree); From f8d7d539cb0d59a33cea96da9f45a4c7f9a907b4 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 15 Jan 2019 18:33:11 -0700 Subject: [PATCH 090/190] Distance2 Graph Coloring Checkpoint COB 2019-01-15 - perf_test compiles - all modes appear to run - further clean up still required - Test also needs fixing. --- perf_test/graph/KokkosGraph_color_d2.cpp | 1 + src/common/KokkosKernels_Handle.hpp | 15 ++- src/graph/KokkosGraph_Distance2Color.hpp | 28 +++-- ...raph_Distance2Color_MatrixSquared_impl.hpp | 100 +++++++++++------- 4 files changed, 89 insertions(+), 55 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index fd7e2ce9bb..91998eee92 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -376,6 +376,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Total Time: " << kh.get_distance2_graph_coloring_handle()->get_overall_coloring_time() << std::endl << "Num colors: " << kh.get_distance2_graph_coloring_handle()->get_num_colors() << std::endl << "Num Phases: " << kh.get_distance2_graph_coloring_handle()->get_num_phases() << std::endl; + std::cout << "\t"; KokkosKernels::Impl::print_1Dview(kh.get_distance2_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index ddf498514c..e4a775beef 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -66,7 +66,6 @@ class KokkosKernelsHandle //typedef Kokkos::Device HandleTempMemorySpace; //typedef Kokkos::Device HandlePersistentMemorySpace; - typedef typename std::remove_const::type size_type; typedef const size_type const_size_type; @@ -137,7 +136,6 @@ class KokkosKernelsHandle this->gsHandle = right_side_handle.get_gs_handle(); this->spgemmHandle = right_side_handle.get_spgemm_handle(); - this->team_work_size = right_side_handle.get_set_team_work_size(); this->shared_memory_size = right_side_handle.get_shmem_size(); this->suggested_team_size = right_side_handle.get_set_suggested_team_size(); @@ -159,9 +157,11 @@ class KokkosKernelsHandle typedef typename KokkosGraph:: GraphColoringHandle GraphColoringHandleType; + typedef typename KokkosGraph:: Distance2GraphColoringHandle Distance2GraphColoringHandleType; + typedef typename KokkosSparse:: GaussSeidelHandle GaussSeidelHandleType; @@ -195,6 +195,7 @@ class KokkosKernelsHandle GraphColoringHandleType *gcHandle; Distance2GraphColoringHandleType *gcHandle_d2; + GaussSeidelHandleType *gsHandle; SPGEMMHandleType *spgemmHandle; SPADDHandleType *spaddHandle; @@ -214,7 +215,6 @@ class KokkosKernelsHandle bool is_owner_of_the_spgemm_handle; bool is_owner_of_the_spadd_handle; - public: KokkosKernelsHandle() @@ -406,6 +406,10 @@ class KokkosKernelsHandle // Distance-1 Graph Coloring GraphColoringHandleType *get_graph_coloring_handle(){ + if(!this->is_owner_of_the_gc_handle) + { + throw std::runtime_error("Graph coloring handle has not been created."); + } return this->gcHandle; } void create_graph_coloring_handle(KokkosGraph::ColoringAlgorithm coloring_type = KokkosGraph::COLORING_DEFAULT){ @@ -414,7 +418,6 @@ class KokkosKernelsHandle this->gcHandle = new GraphColoringHandleType(); this->gcHandle->set_algorithm(coloring_type, true); this->gcHandle->set_tictoc(KKVERBOSE); - } void destroy_graph_coloring_handle(){ if (is_owner_of_the_gc_handle && this->gcHandle != NULL){ @@ -428,6 +431,10 @@ class KokkosKernelsHandle // Distance-2 Graph Coloring Distance2GraphColoringHandleType *get_distance2_graph_coloring_handle() { + if(!this->is_owner_of_the_d2_gc_handle) + { + throw std::runtime_error("D2 graph coloring handle has not been created."); + } return this->gcHandle_d2; } void create_distance2_graph_coloring_handle(KokkosGraph::GraphColoringAlgorithmDistance2 coloring_type = KokkosGraph::COLORING_D2_DEFAULT) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 518ee5b908..e331c06da8 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -79,11 +79,7 @@ void graph_color_d2(KernelHandle *handle, GraphColoringAlgorithmDistance2 algorithm = gch_d2->get_coloring_algo_type(); // Create a view to save the colors to. - // - Note: color_view_t is a Kokkos::View color_view_t (KokkosGraph_GraphColorHandle.hpp) - // a 1D array of color_t - using color_view_type = typename KernelHandle::Distance2GraphColoringHandleType::color_view_t; - color_view_type colors_out("Graph Colors", num_rows); switch(algorithm) @@ -92,9 +88,16 @@ void graph_color_d2(KernelHandle *handle, { Impl::GraphColorD2_MatrixSquared gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); + gc.execute(); - break; + + // WCMCLEN (SCAFFOLDING) - Segfault for Matrix^2 based D2 Coloring is probably because it uses distance-1 graph coloring + // so there's no 'd2' coloring handle. Can we dump the colors and information from the run + // into the D2 coloring handle? + } + break; + #if 1 // WCMCLEN SCAFFOLDING (the original d2 coloring in serial is in the GraphColor handle :/ ) case COLORING_D2_SERIAL: { @@ -109,13 +112,14 @@ void graph_color_d2(KernelHandle *handle, gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); // Save out the number of phases and vertex colors - gch_d1->set_vertex_colors(colors_out); - gch_d1->set_num_phases((double)num_phases); + gch_d2->set_vertex_colors(colors_out); + gch_d2->set_num_phases((double)num_phases); + #else throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); #endif - break; } + break; #endif case COLORING_D2: @@ -125,14 +129,18 @@ void graph_color_d2(KernelHandle *handle, { Impl::GraphColorD2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); + gc.execute(); + + double coloring_time = timer.seconds(); + gch_d2->add_to_overall_coloring_time(coloring_time); + gch_d2->set_coloring_time(coloring_time); + break; } default: - { break; - } } double coloring_time = timer.seconds(); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 02495fb1b8..0d9a41b2fd 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -67,52 +67,56 @@ namespace Impl { * e.g. no vertex having same color shares an edge. * General aim is to find the minimum number of colors, minimum number of independent sets. */ -template +template class GraphColorD2_MatrixSquared { public: typedef lno_row_view_t_ in_lno_row_view_t; typedef lno_nnz_view_t_ in_lno_nnz_view_t; - typedef typename HandleType::GraphColoringHandleType::color_t color_t; - typedef typename HandleType::GraphColoringHandleType::color_view_t color_view_type; + typedef typename HandleType::Distance2GraphColoringHandleType::color_t color_t; + typedef typename HandleType::Distance2GraphColoringHandleType::color_view_t color_view_type; typedef typename HandleType::size_type size_type; typedef typename HandleType::nnz_lno_t nnz_lno_t; - typedef typename HandleType::HandleExecSpace MyExecSpace; + typedef typename HandleType::HandleExecSpace MyExecSpace; typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::const_size_type const_size_type; + typedef typename HandleType::const_size_type const_size_type; - typedef typename lno_row_view_t_::device_type row_lno_view_device_t; - typedef typename lno_row_view_t_::const_type const_lno_row_view_t; - typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; + typedef typename lno_row_view_t_::device_type row_lno_view_device_t; + typedef typename lno_row_view_t_::const_type const_lno_row_view_t; + typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - typedef typename clno_row_view_t_::const_type const_clno_row_view_t; - typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; + typedef typename clno_row_view_t_::const_type const_clno_row_view_t; + typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; - typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; + typedef typename HandleType::size_type_temp_work_view_t size_type_temp_work_view_t; + typedef typename HandleType::scalar_temp_work_view_t scalar_temp_work_view_t; typedef typename HandleType::nnz_lno_persistent_work_view_t nnz_lno_persistent_work_view_t; - typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; + typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; typedef typename Kokkos::View single_dim_index_view_type; typedef Kokkos::RangePolicy my_exec_space; protected: - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) + nnz_lno_t nr; // num_rows (# verts) + nnz_lno_t nc; // num cols + size_type ne; // # edges + const_lno_row_view_t xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - HandleType *cp; // the handle. + nnz_lno_t nv; // num vertices + HandleType* handle; // the handle. bool verbose; @@ -127,15 +131,24 @@ class GraphColorD2_MatrixSquared * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorD2_MatrixSquared(nnz_lno_t nr_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, + GraphColorD2_MatrixSquared(nnz_lno_t nr_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, const_clno_row_view_t t_row_map, const_clno_nnz_view_t t_entries, - HandleType *handle) - : nr(nr_), nc(nc_), ne(ne_), xadj(row_map), adj(entries), t_xadj(t_row_map), t_adj(t_entries), nv(nr_), cp(handle), verbose(handle->get_verbose()) + HandleType* handle) + : nr(nr_) + , nc(nc_) + , ne(ne_) + , xadj(row_map) + , adj(entries) + , t_xadj(t_row_map) + , t_adj(t_entries) + , nv(nr_) + , handle(handle) + , verbose(handle->get_verbose()) { } @@ -157,20 +170,20 @@ class GraphColorD2_MatrixSquared */ virtual void execute() { - double time = 0; + double time = 0; Kokkos::Impl::Timer timer; timer.reset(); std::string algName = "SPGEMM_KK_MEMSPEED"; - cp->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); + handle->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); size_type_temp_work_view_t cRowptrs("cRowptrs", nr + 1); // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) - KokkosSparse::Experimental::spgemm_symbolic(cp, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); + KokkosSparse::Experimental::spgemm_symbolic(handle, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); // Get num nz in C - auto Cnnz = cp->get_spgemm_handle()->get_c_nnz(); + auto Cnnz = handle->get_spgemm_handle()->get_c_nnz(); // Must create placeholder value views for A and C (values are meaningless) // Said above that the scalar view type is the same as the colinds view type @@ -178,40 +191,45 @@ class GraphColorD2_MatrixSquared // Allocate C entries array, and placeholder values nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); - scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); // Run the numeric kernel - KokkosSparse::Experimental::spgemm_numeric(cp, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); + KokkosSparse::Experimental::spgemm_numeric( + handle, nr, nc, nr, xadj, adj, aFakeValues, false, t_xadj, t_adj, aFakeValues, false, cRowptrs, cColinds, cFakeValues); if(this->verbose) { time = timer.seconds(); std::cout << "\tTime Phase Square Matrix : " << time << std::endl << std::endl; - this->cp->get_graph_coloring_handle()->add_to_overall_coloring_time_phase4(time); + this->handle->get_distance2_graph_coloring_handle()->add_to_overall_coloring_time_phase4(time); timer.reset(); } // done with spgemm - cp->destroy_spgemm_handle(); + handle->destroy_spgemm_handle(); - // Now run distance-1 graph coloring on C - // Use LocalOrdinal for storing colors - KokkosGraph::Experimental::graph_color(cp, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); + // Now run distance-1 graph coloring on C, use LocalOrdinal for storing colors + handle->create_graph_coloring_handle(); + KokkosGraph::Experimental::graph_color(handle, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); if(this->verbose) { time = timer.seconds(); std::cout << "\tTime Phase Graph Coloring : " << time << std::endl << std::endl; - this->cp->get_graph_coloring_handle()->add_to_overall_coloring_time_phase5(time); + this->handle->get_distance2_graph_coloring_handle()->add_to_overall_coloring_time_phase5(time); timer.reset(); } // extract the colors - // auto coloringHandle = cp->get_graph_coloring_handle(); + // auto coloringHandle = handle->get_graph_coloring_handle(); // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); + // std::cout << "Num phases: " << handle->get_graph_coloring_handle()->get_num_phases() << std::endl; + this->handle->get_distance2_graph_coloring_handle()->set_num_phases(this->handle->get_graph_coloring_handle()->get_num_phases()); + this->handle->get_distance2_graph_coloring_handle()->set_vertex_colors(this->handle->get_graph_coloring_handle()->get_vertex_colors()); + // clean up coloring handle - // cp->destroy_graph_coloring_handle(); + handle->destroy_graph_coloring_handle(); } }; // GraphColorD2_MatrixSquared (end) From b9c32be669d5bfc7035fe5630aaaab2377a04c8d Mon Sep 17 00:00:00 2001 From: William McLendon Date: Mon, 21 Jan 2019 19:21:19 -0700 Subject: [PATCH 091/190] D2 Coloring Testing fixed and working now. --- .../KokkosGraph_Distance2GraphColorHandle.hpp | 6 +- unit_test/graph/Test_Graph_graph_color_d2.hpp | 140 +++++++++--------- 2 files changed, 70 insertions(+), 76 deletions(-) diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp index 10507dd78c..31ae9b6219 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp @@ -386,10 +386,6 @@ class Distance2GraphColoringHandle entries_type& entries, kokkos_view_type& colors) const { - // typedef typename kokkos_view_t::HostMirror h_colors_t; // SCAFFOLDING - // typedef typename rowmap_t::HostMirror h_rowmap_t; // SCAFFOLDING - // typedef typename entries_t::HostMirror h_entries_t; // SCAFFOLDING - using h_colors_type = typename kokkos_view_type::HostMirror; using h_rowmap_type = typename rowmap_type::HostMirror; using h_entries_type = typename entries_type::HostMirror; @@ -427,7 +423,7 @@ class Distance2GraphColoringHandle { os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; } - for(size_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) + for(size_t iadj = h_rowmap(vid); iadj < (size_t)h_rowmap(vid + 1); iadj++) { size_t vadj = h_entries(iadj); if(vadj >= vid) diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_d2.hpp index 0ae0b073dc..1812cd53e6 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_d2.hpp @@ -60,24 +60,29 @@ using namespace KokkosGraph::Experimental; namespace Test { -template +template int -run_graphcolor_d2(crsMat_t input_mat, - GraphColoringAlgorithmDistance2 coloring_algorithm, - size_t& num_colors, - typename crsMat_t::StaticCrsGraphType::entries_type::non_const_type& vertex_colors) +run_graphcolor_d2(crsMat_type input_mat, + GraphColoringAlgorithmDistance2 coloring_algorithm, + size_t& num_colors, + typename crsMat_type::StaticCrsGraphType::entries_type::non_const_type& vertex_colors) { - using graph_t = typename crsMat_t::StaticCrsGraphType; - using lno_view_t = typename graph_t::row_map_type; - using lno_nnz_view_t = typename graph_t::entries_type; - using scalar_view_t = typename crsMat_t::values_type::non_const_type; + using graph_type = typename crsMat_type::StaticCrsGraphType; + using lno_view_type = typename graph_type::row_map_type; + using lno_nnz_view_type = typename graph_type::entries_type; + using scalar_view_type = typename crsMat_type::values_type::non_const_type; - using size_type = typename lno_view_t::value_type; - using lno_t = typename lno_nnz_view_t::value_type; - using scalar_t = typename scalar_view_t::value_type; + using size_type = typename lno_view_type::value_type; + using lno_type = typename lno_nnz_view_type::value_type; + using scalar_type = typename scalar_view_type::value_type; - using KernelHandle = KokkosKernelsHandle; + using KernelHandle = KokkosKernelsHandle; KernelHandle kh; kh.set_team_work_size(16); @@ -88,17 +93,14 @@ run_graphcolor_d2(crsMat_t const size_t num_rows_1 = input_mat.numRows(); const size_t num_cols_1 = input_mat.numCols(); - graph_color_d2(&kh, - num_rows_1, - num_cols_1, - input_mat.graph.row_map, - input_mat.graph.entries, - input_mat.graph.row_map, - input_mat.graph.entries); - -// num_colors = kh.get_graph_coloring_handle()->get_num_colors(); // WCMCLEN -// vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors(); // WCMCLEN -// kh.destroy_graph_coloring_handle(); // WCMCLEN + graph_color_d2(&kh, + num_rows_1, + num_cols_1, + input_mat.graph.row_map, + input_mat.graph.entries, + input_mat.graph.row_map, + input_mat.graph.entries); + num_colors = kh.get_distance2_graph_coloring_handle()->get_num_colors(); vertex_colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); kh.destroy_distance2_graph_coloring_handle(); @@ -109,40 +111,42 @@ run_graphcolor_d2(crsMat_t -template +template void -test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_variance) +test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type row_size_variance) { using namespace Test; - using crsMat_t = KokkosSparse::CrsMatrix; - using graph_t = typename crsMat_t::StaticCrsGraphType; - using lno_view_t = typename graph_t::row_map_type; - using lno_nnz_view_t = typename graph_t::entries_type; - using scalar_view_t = typename crsMat_t::values_type::non_const_type; + using crsMat_type = KokkosSparse::CrsMatrix; + using graph_type = typename crsMat_type::StaticCrsGraphType; + using lno_view_type = typename graph_type::row_map_type; + using lno_nnz_view_type = typename graph_type::entries_type; + using scalar_view_type = typename crsMat_type::values_type::non_const_type; + + using color_view_type = typename graph_type::entries_type::non_const_type; - lno_t numCols = numRows; - crsMat_t input_mat = KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); + lno_type numCols = numRows; + crsMat_type input_mat = KokkosKernels::Impl::kk_generate_sparse_matrix(numRows, numCols, nnz, row_size_variance, bandwidth); - typename lno_view_t::non_const_type sym_xadj; - typename lno_nnz_view_t::non_const_type sym_adj; + typename lno_view_type::non_const_type sym_xadj; + typename lno_nnz_view_type::non_const_type sym_adj; - KokkosKernels::Impl::symmetrize_graph_symbolic_hashmap( numRows, input_mat.graph.row_map, input_mat.graph.entries, sym_xadj, sym_adj); - size_type numentries = sym_adj.extent(0); - scalar_view_t newValues("vals", numentries); + size_type numentries = sym_adj.extent(0); + scalar_view_type newValues("vals", numentries); - graph_t static_graph(sym_adj, sym_xadj); - input_mat = crsMat_t("CrsMatrix", numCols, newValues, static_graph); + graph_type static_graph(sym_adj, sym_xadj); + input_mat = crsMat_type("CrsMatrix", numCols, newValues, static_graph); typedef KokkosKernelsHandle @@ -152,7 +156,7 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v std::string algName = "SPGEMM_KK_MEMSPEED"; cp.create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); - typename graph_t::row_map_type::non_const_type cRowptrs("cRowptrs", numRows + 1); + typename graph_type::row_map_type::non_const_type cRowptrs("cRowptrs", numRows + 1); // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) KokkosSparse::Experimental::spgemm_symbolic(&cp, @@ -171,11 +175,11 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v // Must create placeholder value views for A and C (values are meaningless) // Said above that the scalar view type is the same as the colinds view type - scalar_view_t aFakeValues("A/B placeholder values (meaningless)", input_mat.graph.entries.size()); + scalar_view_type aFakeValues("A/B placeholder values (meaningless)", input_mat.graph.entries.size()); // Allocate C entries array, and placeholder values - typename graph_t::entries_type::non_const_type cColinds("C colinds", Cnnz); - scalar_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + typename graph_type::entries_type::non_const_type cColinds("C colinds", Cnnz); + scalar_view_type cFakeValues("C placeholder values (meaningless)", Cnnz); // Run the numeric kernel KokkosSparse::Experimental::spgemm_numeric(&cp, @@ -196,12 +200,8 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v // done with spgemm cp.destroy_spgemm_handle(); -#if 0 // WCMCLEN SCAFFOLDING (RE-Enable this once the error is fixed for the perf_test example) - GraphColoringAlgorithmDistance2 coloring_algorithms[] = { COLORING_D2_MATRIX_SQUARED, - COLORING_D2_SERIAL, - COLORING_D2, - COLORING_D2_VB, - COLORING_D2_VB_BIT }; + GraphColoringAlgorithmDistance2 coloring_algorithms[] = { + COLORING_D2_MATRIX_SQUARED, COLORING_D2_SERIAL, COLORING_D2, COLORING_D2_VB, COLORING_D2_VB_BIT}; int num_algorithms = 5; @@ -209,39 +209,39 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v { GraphColoringAlgorithmDistance2 coloring_algorithm = coloring_algorithms[ ii ]; - color_view_t vector_colors; - size_t num_colors; + color_view_type vector_colors; + size_t num_colors; Kokkos::Impl::Timer timer1; - crsMat_t output_mat; - int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); + crsMat_type output_mat; + int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); // double coloring_time = timer1.seconds(); EXPECT_TRUE((res == 0)); - const lno_t num_rows_1 = input_mat.numRows(); - const lno_t num_cols_1 = input_mat.numCols(); + const lno_type num_rows_1 = input_mat.numRows(); + const lno_type num_cols_1 = input_mat.numCols(); - lno_t num_conflict = KokkosKernels::Impl:: - kk_is_d1_coloring_valid( + lno_type num_conflict = KokkosKernels::Impl:: + kk_is_d1_coloring_valid( num_rows_1, num_cols_1, cRowptrs, cColinds, vector_colors); - lno_t conf = 0; + lno_type conf = 0; { // also check the correctness of the validation code :) - typename lno_view_t::HostMirror hrm = Kokkos::create_mirror_view(cRowptrs); - typename lno_nnz_view_t::HostMirror hentries = Kokkos::create_mirror_view(cColinds); - typename color_view_t::HostMirror hcolor = Kokkos::create_mirror_view(vector_colors); + typename lno_view_type::HostMirror hrm = Kokkos::create_mirror_view(cRowptrs); + typename lno_nnz_view_type::HostMirror hentries = Kokkos::create_mirror_view(cColinds); + typename color_view_type::HostMirror hcolor = Kokkos::create_mirror_view(vector_colors); Kokkos::deep_copy(hrm, cRowptrs); Kokkos::deep_copy(hentries, cColinds); Kokkos::deep_copy(hcolor, vector_colors); - for(lno_t i = 0; i < num_rows_1; ++i) + for(lno_type i = 0; i < num_rows_1; ++i) { const size_type b = hrm(i); const size_type e = hrm(i + 1); for(size_type j = b; j < e; ++j) { - lno_t d = hentries(j); + lno_type d = hentries(j); if(i != d) { if(hcolor(d) == hcolor(i)) @@ -263,8 +263,6 @@ test_coloring_d2(lno_t numRows, size_type nnz, lno_t bandwidth, lno_t row_size_v EXPECT_STREQ("something", capturedStdout.c_str()); */ } - #endif - // device::execution_space::finalize(); } From b01230166129f81764778a09edf6e8d5f967b5d8 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 22 Jan 2019 10:35:55 -0700 Subject: [PATCH 092/190] Distance2 Coloring Refactor Cleaning up and working on naming consistency, etc. --- perf_test/graph/KokkosGraph_color_d2.cpp | 14 ++--- src/common/KokkosKernels_Handle.hpp | 12 ++--- src/graph/KokkosGraph_Distance2Color.hpp | 45 ++++++++-------- ...KokkosGraph_GraphColorDistance2Handle.hpp} | 10 ++-- ...raph_Distance2Color_MatrixSquared_impl.hpp | 12 ++--- .../impl/KokkosGraph_Distance2Color_impl.hpp | 52 +++++++++++-------- .../impl/KokkosSparse_spgemm_impl_color.hpp | 8 +-- .../cuda/Test_Cuda_Graph_graph_color_d2.cpp | 2 +- ...p => Test_Graph_graph_color_distance2.hpp} | 14 ++--- .../Test_OpenMP_Graph_graph_color_d2.cpp | 2 +- .../Test_Serial_Graph_graph_color_d2.cpp | 2 +- .../Test_Threads_Graph_graph_color_d2.cpp | 2 +- 12 files changed, 92 insertions(+), 83 deletions(-) rename src/graph/{KokkosGraph_Distance2GraphColorHandle.hpp => KokkosGraph_GraphColorDistance2Handle.hpp} (99%) rename unit_test/graph/{Test_Graph_graph_color_d2.hpp => Test_Graph_graph_color_distance2.hpp} (98%) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 91998eee92..13e86ad6d2 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -362,13 +362,13 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { - graph_color_d2(&kh, - crsGraph.numRows(), - crsGraph.numCols(), - crsGraph.row_map, - crsGraph.entries, - crsGraph.row_map, - crsGraph.entries); + graph_color_distance2(&kh, + crsGraph.numRows(), + crsGraph.numCols(), + crsGraph.row_map, + crsGraph.entries, + crsGraph.row_map, + crsGraph.entries); total_colors += kh.get_distance2_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_distance2_graph_coloring_handle()->get_num_phases(); diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index e4a775beef..ac8ed1b894 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -42,7 +42,7 @@ */ #include #include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_Distance2GraphColorHandle.hpp" +#include "KokkosGraph_GraphColorDistance2Handle.hpp" #include "KokkosSparse_gauss_seidel_handle.hpp" #include "KokkosSparse_spgemm_handle.hpp" #include "KokkosSparse_spadd_handle.hpp" @@ -159,8 +159,8 @@ class KokkosKernelsHandle GraphColoringHandleType; typedef typename KokkosGraph:: - Distance2GraphColoringHandle - Distance2GraphColoringHandleType; + GraphColorDistance2Handle + GraphColorDistance2HandleType; typedef typename KokkosSparse:: GaussSeidelHandle @@ -194,7 +194,7 @@ class KokkosKernelsHandle private: GraphColoringHandleType *gcHandle; - Distance2GraphColoringHandleType *gcHandle_d2; + GraphColorDistance2HandleType *gcHandle_d2; GaussSeidelHandleType *gsHandle; SPGEMMHandleType *spgemmHandle; @@ -429,7 +429,7 @@ class KokkosKernelsHandle // Distance-2 Graph Coloring - Distance2GraphColoringHandleType *get_distance2_graph_coloring_handle() + GraphColorDistance2HandleType *get_distance2_graph_coloring_handle() { if(!this->is_owner_of_the_d2_gc_handle) { @@ -441,7 +441,7 @@ class KokkosKernelsHandle { this->destroy_distance2_graph_coloring_handle(); this->is_owner_of_the_d2_gc_handle = true; - this->gcHandle_d2 = new Distance2GraphColoringHandleType(); + this->gcHandle_d2 = new GraphColorDistance2HandleType(); this->gcHandle_d2->set_algorithm(coloring_type, true); this->gcHandle_d2->set_tictoc(KKVERBOSE); this->gcHandle_d2->set_verbose(KKVERBOSE); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index e331c06da8..b0ee7a25d1 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -40,14 +40,15 @@ // ************************************************************************ //@HEADER */ -#ifndef _KOKKOS_GRAPH_COLORD2_HPP -#define _KOKKOS_GRAPH_COLORD2_HPP +#ifndef _KOKKOS_GRAPH_COLORDISTANCE2_HPP +#define _KOKKOS_GRAPH_COLORDISTANCE2_HPP +#include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_GraphColorDistance2Handle.hpp" #include "KokkosGraph_GraphColor_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_Distance2GraphColorHandle.hpp" + #include "KokkosKernels_Utils.hpp" @@ -61,32 +62,32 @@ namespace Experimental { * Distance 2 Graph Coloring */ template -void graph_color_d2(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries) +void graph_color_distance2(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries) { Kokkos::Impl::Timer timer; // Set our handle pointer to a GraphColoringHandleType. - typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); // Get the algorithm we're running from the graph coloring handle. GraphColoringAlgorithmDistance2 algorithm = gch_d2->get_coloring_algo_type(); // Create a view to save the colors to. - using color_view_type = typename KernelHandle::Distance2GraphColoringHandleType::color_view_t; + using color_view_type = typename KernelHandle::GraphColorDistance2HandleType::color_view_t; color_view_type colors_out("Graph Colors", num_rows); switch(algorithm) { case COLORING_D2_MATRIX_SQUARED: { - Impl::GraphColorD2_MatrixSquared + Impl::GraphColorDistance2MatrixSquared gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); gc.execute(); @@ -127,7 +128,7 @@ void graph_color_d2(KernelHandle *handle, case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: { - Impl::GraphColorD2 + Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); gc.execute(); @@ -184,9 +185,9 @@ void computeDistance2Degree(KernelHandle *handle, typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, size_t& degree_d2_max) { - typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - Impl::GraphColorD2 + Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); gc.calculate_d2_degree(degree_d2_dist, degree_d2_max); @@ -220,9 +221,9 @@ bool verifyDistance2Coloring(KernelHandle *handle, { bool output = true; - typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - Impl::GraphColorD2 + Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); @@ -245,9 +246,9 @@ void printDistance2ColorsHistogram(KernelHandle *handle, lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries, bool csv=false) { - typename KernelHandle::Distance2GraphColoringHandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - Impl::GraphColorD2 + Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); if(csv) diff --git a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp similarity index 99% rename from src/graph/KokkosGraph_Distance2GraphColorHandle.hpp rename to src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index 31ae9b6219..5c3eb25ff3 100644 --- a/src/graph/KokkosGraph_Distance2GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -47,8 +47,8 @@ #include #include -#ifndef _DISTANCE2GRAPHCOLORHANDLE_HPP -#define _DISTANCE2GRAPHCOLORHANDLE_HPP +#ifndef _GRAPHCOLORDISTANCE2HANDLE_HPP +#define _GRAPHCOLORDISTANCE2HANDLE_HPP namespace KokkosGraph { @@ -68,7 +68,7 @@ enum GraphColoringAlgorithmDistance2 template -class Distance2GraphColoringHandle +class GraphColorDistance2Handle { public: @@ -148,7 +148,7 @@ class Distance2GraphColoringHandle /** * \brief Default constructor. */ - Distance2GraphColoringHandle() + GraphColorDistance2Handle() : coloring_algorithm_type(COLORING_D2_DEFAULT) , verbose(false) , tictoc(false) @@ -315,7 +315,7 @@ class Distance2GraphColoringHandle /** * \brief Destructor */ - virtual ~Distance2GraphColoringHandle(){}; + virtual ~GraphColorDistance2Handle(){}; // getters and setters GraphColoringAlgorithmDistance2 get_coloring_algo_type() const { return this->coloring_algorithm_type; } diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 0d9a41b2fd..b26c39f5cb 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -72,14 +72,14 @@ template -class GraphColorD2_MatrixSquared +class GraphColorDistance2MatrixSquared { public: typedef lno_row_view_t_ in_lno_row_view_t; typedef lno_nnz_view_t_ in_lno_nnz_view_t; - typedef typename HandleType::Distance2GraphColoringHandleType::color_t color_t; - typedef typename HandleType::Distance2GraphColoringHandleType::color_view_t color_view_type; + typedef typename HandleType::GraphColorDistance2HandleType::color_t color_t; + typedef typename HandleType::GraphColorDistance2HandleType::color_view_t color_view_type; typedef typename HandleType::size_type size_type; typedef typename HandleType::nnz_lno_t nnz_lno_t; @@ -131,7 +131,7 @@ class GraphColorD2_MatrixSquared * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorD2_MatrixSquared(nnz_lno_t nr_, + GraphColorDistance2MatrixSquared(nnz_lno_t nr_, nnz_lno_t nc_, size_type ne_, const_lno_row_view_t row_map, @@ -155,7 +155,7 @@ class GraphColorD2_MatrixSquared /** \brief GraphColor destructor. */ - virtual ~GraphColorD2_MatrixSquared() {} + virtual ~GraphColorDistance2MatrixSquared() {} /** @@ -232,7 +232,7 @@ class GraphColorD2_MatrixSquared handle->destroy_graph_coloring_handle(); } -}; // GraphColorD2_MatrixSquared (end) +}; // GraphColorDistance2MatrixSquared (end) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 4cca060d5a..98d9574db1 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -60,7 +60,7 @@ #include "KokkosGraph_GraphColor.hpp" #include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this -#include "KokkosGraph_Distance2GraphColorHandle.hpp" +#include "KokkosGraph_GraphColorDistance2Handle.hpp" #include "KokkosKernels_Handle.hpp" @@ -80,9 +80,9 @@ namespace Impl { * */ template -class GraphColorD2 +class GraphColorDistance2 { - // static_assert( std::is_same< HandleType, KokkosGraph::Distance2GraphColoringHandle>::value, "Incorrect HandleType for this class."); + // static_assert( std::is_same< HandleType, KokkosGraph::GraphColorDistance2Handle>::value, "Incorrect HandleType for this class."); public: typedef lno_row_view_t_ in_lno_row_view_t; @@ -154,7 +154,7 @@ class GraphColorD2 public: /** - * \brief GraphColor constructor. + * \brief GraphColorDistance2 constructor. * \param nv_: number of vertices in the graph * \param ne_: number of edges in the graph * \param row_map: the xadj array of the graph. Its size is nv_ +1 @@ -162,14 +162,14 @@ class GraphColorD2 * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorD2(nnz_lno_t nv_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType* handle) + GraphColorDistance2(nnz_lno_t nv_, + nnz_lno_t nc_, + size_type ne_, + const_lno_row_view_t row_map, + const_lno_nnz_view_t entries, + const_clno_row_view_t t_row_map, + const_clno_nnz_view_t t_entries, + HandleType* handle) : nv(nv_) , nr(nv_) , nc(nc_) @@ -191,20 +191,18 @@ class GraphColorD2 /** * \brief GraphColor destructor. */ - virtual ~GraphColorD2() {} + virtual ~GraphColorDistance2() {} // ----------------------------------------------------------------- // - // GraphColorD2::execute() + // GraphColorDistance2::execute() // // ----------------------------------------------------------------- virtual void execute() { - std::cout << ">>> GraphColorD2::execute()" << std::endl; - color_view_type colors_out("Graph Colors", this->nv); // If the selected pass is using edge filtering we should set the flag. @@ -273,6 +271,7 @@ class GraphColorD2 next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); nnz_lno_t numUncolored = this->nv; + nnz_lno_t numUncoloredPreviousIter = this->nv + 1; nnz_lno_t current_vertexListLength = this->nv; double time; @@ -284,6 +283,9 @@ class GraphColorD2 { timer.reset(); + // Save the # of uncolored from the previous iteration + numUncoloredPreviousIter = numUncolored; + // ------------------------------------------ // Do greedy color // ------------------------------------------ @@ -370,7 +372,11 @@ class GraphColorD2 next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); } } - } // end for iter... + + // Bail out if we didn't make any progress since we're probably stuck and it's better to just clean up in serial. + if(numUncolored == numUncoloredPreviousIter) break; + + } // end for iterations && numUncolored > 0... // ------------------------------------------ // clean up in serial (resolveConflictsSerial) @@ -603,7 +609,7 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::colorGreedy() + // GraphColorDistance2::colorGreedy() // // ----------------------------------------------------------------- void colorGreedy(const_lno_row_view_t xadj_, @@ -659,7 +665,7 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::colorGreedyEF() + // GraphColorDistance2::colorGreedyEF() // // ----------------------------------------------------------------- void colorGreedyEF(const_lno_row_view_t xadj_, @@ -696,7 +702,7 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::findConflicts() + // GraphColorDistance2::findConflicts() // // ----------------------------------------------------------------- template @@ -727,7 +733,7 @@ class GraphColorD2 // ----------------------------------------------------------------- // - // GraphColorD2::resolveConflictsSerial() + // GraphColorDistance2::resolveConflictsSerial() // // ----------------------------------------------------------------- template @@ -1567,7 +1573,9 @@ class GraphColorD2 _m_space.release_chunk(globally_used_hash_indices); } // operator() (end) }; // struct functorCalculateD2Degree (end) -}; // end class GraphColorD2 + + +}; // end class GraphColorDistance2 } // namespace Impl diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index 9d8913d68e..c241736323 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -516,10 +516,10 @@ void KokkosGraph::Experimental::d2_graph_color (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); - // WCMCLEN: SCAFFOLDING -// handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); -// KokkosGraph::Experimental::graph_color_d2 -// (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); + // WCMCLEN: SCAFFOLDING / EXPERIMENTAL + // handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); + // KokkosGraph::Experimental::graph_color_distance2 + // (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); original_num_colors = handle->get_graph_coloring_handle()->get_num_colors(); diff --git a/unit_test/cuda/Test_Cuda_Graph_graph_color_d2.cpp b/unit_test/cuda/Test_Cuda_Graph_graph_color_d2.cpp index 0a774b03d2..d5fdb036a2 100644 --- a/unit_test/cuda/Test_Cuda_Graph_graph_color_d2.cpp +++ b/unit_test/cuda/Test_Cuda_Graph_graph_color_d2.cpp @@ -1,2 +1,2 @@ #include -#include +#include diff --git a/unit_test/graph/Test_Graph_graph_color_d2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp similarity index 98% rename from unit_test/graph/Test_Graph_graph_color_d2.hpp rename to unit_test/graph/Test_Graph_graph_color_distance2.hpp index 1812cd53e6..f02966841d 100644 --- a/unit_test/graph/Test_Graph_graph_color_d2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -93,13 +93,13 @@ run_graphcolor_d2(crsMat_type const size_t num_rows_1 = input_mat.numRows(); const size_t num_cols_1 = input_mat.numCols(); - graph_color_d2(&kh, - num_rows_1, - num_cols_1, - input_mat.graph.row_map, - input_mat.graph.entries, - input_mat.graph.row_map, - input_mat.graph.entries); + graph_color_distance2(&kh, + num_rows_1, + num_cols_1, + input_mat.graph.row_map, + input_mat.graph.entries, + input_mat.graph.row_map, + input_mat.graph.entries); num_colors = kh.get_distance2_graph_coloring_handle()->get_num_colors(); vertex_colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); diff --git a/unit_test/openmp/Test_OpenMP_Graph_graph_color_d2.cpp b/unit_test/openmp/Test_OpenMP_Graph_graph_color_d2.cpp index 2ed88fcf88..73a09d8283 100644 --- a/unit_test/openmp/Test_OpenMP_Graph_graph_color_d2.cpp +++ b/unit_test/openmp/Test_OpenMP_Graph_graph_color_d2.cpp @@ -1,2 +1,2 @@ #include -#include +#include diff --git a/unit_test/serial/Test_Serial_Graph_graph_color_d2.cpp b/unit_test/serial/Test_Serial_Graph_graph_color_d2.cpp index 4189a49152..e5e2206a3c 100644 --- a/unit_test/serial/Test_Serial_Graph_graph_color_d2.cpp +++ b/unit_test/serial/Test_Serial_Graph_graph_color_d2.cpp @@ -1,2 +1,2 @@ #include -#include +#include diff --git a/unit_test/threads/Test_Threads_Graph_graph_color_d2.cpp b/unit_test/threads/Test_Threads_Graph_graph_color_d2.cpp index a5ec58c6c3..87a60964da 100644 --- a/unit_test/threads/Test_Threads_Graph_graph_color_d2.cpp +++ b/unit_test/threads/Test_Threads_Graph_graph_color_d2.cpp @@ -1,3 +1,3 @@ #include -#include +#include From 35900f392f2b1bfbb7f89058abe36458aa1652b9 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 22 Jan 2019 12:27:54 -0700 Subject: [PATCH 093/190] Distance-2 Graph Coloring cleanup checkpoint --- perf_test/graph/KokkosGraph_color_d2.cpp | 37 +--- src/graph/KokkosGraph_Distance2Color.hpp | 191 +++++++++++------- .../KokkosGraph_GraphColorDistance2Handle.hpp | 124 +++++++----- ...raph_Distance2Color_MatrixSquared_impl.hpp | 2 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 128 ++++++------ .../impl/KokkosSparse_spgemm_impl_color.hpp | 2 +- .../Test_Graph_graph_color_distance2.hpp | 9 +- 7 files changed, 272 insertions(+), 221 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 13e86ad6d2..eea8908d81 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -362,13 +362,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Loop over # of experiments to run for(int i = 0; i < repeat; ++i) { - graph_color_distance2(&kh, - crsGraph.numRows(), - crsGraph.numCols(), - crsGraph.row_map, - crsGraph.entries, - crsGraph.row_map, - crsGraph.entries); + graph_compute_distance2_color(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries); total_colors += kh.get_distance2_graph_coloring_handle()->get_num_colors(); total_phases += kh.get_distance2_graph_coloring_handle()->get_num_phases(); @@ -382,15 +376,11 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << std::endl; // If verbose mode is on and there the graph has fewer than 1000 verts, dump a GraphVIZ DOT file. - if(verbose && repeat==i+1 && crsGraph.numRows() < 1000) + if(verbose && repeat==i+1 && crsGraph.numRows() < 1500) { auto colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); std::ofstream os("G.dot", std::ofstream::out); - kh.get_distance2_graph_coloring_handle()->graphToGraphviz(os, - crsGraph.numRows(), - crsGraph.row_map, - crsGraph.entries, - colors); + kh.get_distance2_graph_coloring_handle()->dump_graphviz(os, crsGraph.numRows(), crsGraph.row_map, crsGraph.entries, colors); } // ------------------------------------------ @@ -399,14 +389,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) bool d2_coloring_is_valid = false; bool d2_coloring_validation_flags[4] = {false}; - d2_coloring_is_valid = verifyDistance2Coloring(&kh, - crsGraph.numRows(), - crsGraph.numCols(), - crsGraph.row_map, - crsGraph.entries, - crsGraph.row_map, - crsGraph.entries, - d2_coloring_validation_flags); + d2_coloring_is_valid = graph_verify_distance2_color(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, d2_coloring_validation_flags); // Print out messages based on coloring validation check. if(d2_coloring_is_valid) @@ -432,7 +415,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // ------------------------------------------ // Print out the colors histogram // ------------------------------------------ - printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); + graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); } // for i... @@ -451,10 +434,10 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); size_t degree_d2_max=0; - computeDistance2Degree(&kh, crsGraph.numRows(), crsGraph.numCols(), - crsGraph.row_map, crsGraph.entries, - crsGraph.row_map, crsGraph.entries, - degree_d2_dist, degree_d2_max); + graph_compute_distance2_degree(&kh, crsGraph.numRows(), crsGraph.numCols(), + crsGraph.row_map, crsGraph.entries, + crsGraph.row_map, crsGraph.entries, + degree_d2_dist, degree_d2_max); time_d2_degree = timer.seconds(); #endif @@ -596,7 +579,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << label_algorithm << "," << Kokkos::DefaultExecutionSpace::concurrency() << ","; - printDistance2ColorsHistogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); + graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); std::cout << std::endl; // Kokkos::print_configuration(std::cout); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index b0ee7a25d1..2696d54360 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -58,18 +58,32 @@ namespace KokkosGraph { namespace Experimental { + /** - * Distance 2 Graph Coloring + * Compute the distance-2 coloring of the matrix/graph. + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @param[in] handle The Kernel Handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map Row map + * @param[in] row_entries Row entries + * @param[in] col_map Column map + * @param[in] col_entries Column entries + * + * @return Nothing */ template -void graph_color_distance2(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries) +void graph_compute_distance2_color(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries) { Kokkos::Impl::Timer timer; @@ -90,18 +104,14 @@ void graph_color_distance2(KernelHandle *handle, Impl::GraphColorDistance2MatrixSquared gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); - gc.execute(); - - // WCMCLEN (SCAFFOLDING) - Segfault for Matrix^2 based D2 Coloring is probably because it uses distance-1 graph coloring - // so there's no 'd2' coloring handle. Can we dump the colors and information from the run - // into the D2 coloring handle? - + gc.compute_distance2_color(); } break; - #if 1 // WCMCLEN SCAFFOLDING (the original d2 coloring in serial is in the GraphColor handle :/ ) case COLORING_D2_SERIAL: { + // todo: The original Serial D2 coloring code is in GraphColorHandle. This should get moved to the + // distance-2 coloring handle but that might break backwards compatibility. #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; @@ -121,7 +131,6 @@ void graph_color_distance2(KernelHandle *handle, #endif } break; - #endif case COLORING_D2: case COLORING_D2_VB: @@ -131,7 +140,7 @@ void graph_color_distance2(KernelHandle *handle, Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - gc.execute(); + gc.compute_distance2_color(); double coloring_time = timer.seconds(); gch_d2->add_to_overall_coloring_time(coloring_time); @@ -151,73 +160,83 @@ void graph_color_distance2(KernelHandle *handle, /** - * Compute Distance-2 Degree Stats + * Compute Distance-2 Degree Stats * - * Distance-2 Degree of a vertex, v, is the sum of the degree of all neighbors of v. + * Distance-2 Degree of a vertex, v, is the sum of the degree of all neighbors of v. * - * This function calculates the distance-2 degree of all the vertices in the graph, - * the maximum distance-2 degree, and the sum of all the distance-2 degrees. + * This function calculates the distance-2 degree of all the vertices in the graph, + * the maximum distance-2 degree, and the sum of all the distance-2 degrees. * - * @param[in] handle The Kernel Handle - * @param[in] num_rows Number of rows in the matrix (number of vertices) - * @param[in] num_cols Number of columns in the matrix - * @param[in] row_map Row map - * @param[in] row_entries Row entries - * @param[in] col_map Column map - * @param[in] col_entries Column entries - * @param[out] degree_d2_dist View to fill with distance-2 degree information. - * @param[out] degree_d2_max Maximum distance-2 degree found. - * @param[out] degree_d2_sum Sum of all distance-2 degrees. + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. * - * Note: If the graph is symmetric, give the same value for col_map and row_map, - * and for row_entries and col_entries. + * @param[in] handle The Kernel Handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map Row map + * @param[in] row_entries Row entries + * @param[in] col_map Column map + * @param[in] col_entries Column entries + * @param[out] degree_d2_dist View to fill with distance-2 degree information. + * @param[out] degree_d2_max Maximum distance-2 degree found. + * @param[out] degree_d2_sum Sum of all distance-2 degrees. * - * @return Nothing + * @return Nothing */ template -void computeDistance2Degree(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, - size_t& degree_d2_max) +void graph_compute_distance2_degree(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, + size_t& degree_d2_max) { typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - gc.calculate_d2_degree(degree_d2_dist, degree_d2_max); + gc.compute_distance2_degree(degree_d2_dist, degree_d2_max); } /** - * Validate Distance 2 Graph Coloring + * Validate Distance 2 Graph Coloring + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. * - * @param validation_flags is an array of 4 booleans. - * validation_flags[0] : True IF the distance-2 coloring is invalid. - * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. - * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices - * at distance=2 from each other has the same color. - * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. - * May not be an INVALID coloring, but can indicate poor quality in coloring. + * @param[in] handle The kernel handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map The row map + * @param[in] row_entries The row entries + * @param[in] col_map The column map + * @param[in] col_entries The column entries + * @param[out] validation_flags An array of 4 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. + * May not be an INVALID coloring, but can indicate poor quality in coloring. * - * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. + * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. */ template -bool verifyDistance2Coloring(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - bool validation_flags[]) +bool graph_verify_distance2_color(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + bool validation_flags[]) { bool output = true; @@ -226,7 +245,7 @@ bool verifyDistance2Coloring(KernelHandle *handle, Impl::GraphColorDistance2 gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - output = gc.verifyDistance2Coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); + output = gc.verify_coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); return output; } @@ -234,17 +253,39 @@ bool verifyDistance2Coloring(KernelHandle *handle, /** - * Print out a histogram of graph colors for Distance-2 Graph Coloring + * Prints out a histogram of graph colors for Distance-2 Graph Coloring + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @param[in] handle The kernel handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map The row map + * @param[in] row_entries The row entries + * @param[in] col_map The column map + * @param[in] col_entries The column entries + * @param[out] validation_flags An array of 4 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. + * May not be an INVALID coloring, but can indicate poor quality in coloring. + * @param[in] csv Output in CSV format? Default: false + * + * @return nothing */ template -void printDistance2ColorsHistogram(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, bool csv=false) +void graph_print_distance2_color_histogram(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + bool csv=false) { typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); @@ -253,11 +294,11 @@ void printDistance2ColorsHistogram(KernelHandle *handle, if(csv) { - gc.printDistance2ColorsHistogramCSV(); + gc.print_color_histogram_csv(); } else { - gc.printDistance2ColorsHistogram(); + gc.print_color_histogram(); } } diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index 5c3eb25ff3..0d0f77e0fd 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -97,11 +97,11 @@ class GraphColorDistance2Handle typedef typename Kokkos::View size_type_temp_work_view_t; typedef typename Kokkos::View size_type_persistent_work_view_t; - typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; // Host view type + typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; // Host view type typedef typename Kokkos::View nnz_lno_temp_work_view_t; typedef typename Kokkos::View nnz_lno_persistent_work_view_t; - typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; // Host view type + typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; // Host view type typedef Kokkos::TeamPolicy team_policy_t; typedef typename team_policy_t::member_type team_member_t; @@ -111,12 +111,12 @@ class GraphColorDistance2Handle private: // Parameters - GraphColoringAlgorithmDistance2 coloring_algorithm_type; // VB, VBBIT, VBCS, VBD or EB. + GraphColoringAlgorithmDistance2 coloring_algorithm_type; // Which algorithm type to use. bool verbose; // verbosity flag bool tictoc; // print time at every step - bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. + bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. int vb_chunk_size; // the (minimum) size of the consecutive works that a thread will be assigned to. int max_number_of_iterations; // maximum allowed number of phases that @@ -173,9 +173,17 @@ class GraphColorDistance2Handle } - /** \brief Changes the graph coloring algorithm. - * \param col_algo: Coloring algorithm: one of COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB - * \param set_default_parameters: whether or not to reset the default parameters for the given algorithm. + /** Changes the graph coloring algorithm. + * @param[in] col_algo Coloring algorithm, one of: + * - COLORING_D2_DEFAULT + * - COLORING_D2_SERIAL + * - COLORING_D2_MATRIX_SQUARED + * - COLORING_D2_VB + * - COLORING_D2_VB_BIT + * - COLORING_D2_VB_BIT_EF + * + * @param[in] set_default_parameters Whether or not to reset the default parameters for the given algorithm. + * @return None */ void set_algorithm(const GraphColoringAlgorithmDistance2 &col_algo, bool set_default_parameters = true) { @@ -194,7 +202,13 @@ class GraphColorDistance2Handle } - /** \brief Chooses best algorithm based on the execution space. COLORING_EB if cuda, COLORING_VB otherwise. + /** + * Chooses best algorithm based on the execution space. + * + * This chooses the best algorithm based on the execution space: + * - COLORING_D2_SERIAL if the execution space is SERIAL + * - COLORING_D2_VB_BIT otherwise + * */ void choose_default_algorithm() { @@ -250,33 +264,6 @@ class GraphColorDistance2Handle } - struct ReduceMaxFunctor - { - color_view_t colors; - ReduceMaxFunctor(color_view_t cat) : colors(cat) {} - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t& i, color_t& color_max) const - { - if(color_max < colors(i)) - color_max = colors(i); - } - - // max -plus semiring equivalent of "plus" - KOKKOS_INLINE_FUNCTION - void join(volatile color_t& dst, const volatile color_t& src) const - { - if(dst < src) - { - dst = src; - } - } - - KOKKOS_INLINE_FUNCTION - void init(color_t& dst) const { dst = 0; } - }; - - nnz_lno_t get_num_colors() { if(num_colors == 0) @@ -288,7 +275,6 @@ class GraphColorDistance2Handle } - /** \brief Sets Default Parameter settings for the given algorithm. */ void set_defaults(const GraphColoringAlgorithmDistance2 &col_algo) @@ -371,20 +357,21 @@ class GraphColorDistance2Handle } - // Print / write out the graph in a GraphVIZ format. - // Color "1" will be rendered as a red circle. - // Color "0" (uncolored) will be a star shape. - // Other node colors shown as just the color value. - // - // @param os use std::cout for output to STDOUT stream, or a ofstream object - // (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write - // to a file. + /** Print / write out the graph in a GraphVIZ format. + * Color "1" will be rendered as a red circle. + * Color "0" (uncolored) will be a star shape. + * Other node colors shown as just the color value. + * + * @param[in] os use std::cout for output to STDOUT stream, or a ofstream object + * (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write + * to a file. + */ template - void graphToGraphviz(std::ostream& os, - const size_t num_verts, - rowmap_type& rowmap, - entries_type& entries, - kokkos_view_type& colors) const + void dump_graphviz(std::ostream& os, + const size_t num_verts, + rowmap_type& rowmap, + entries_type& entries, + kokkos_view_type& colors) const { using h_colors_type = typename kokkos_view_type::HostMirror; using h_rowmap_type = typename rowmap_type::HostMirror; @@ -434,8 +421,43 @@ class GraphColorDistance2Handle os << std::endl; } os << "}" << std::endl; - } // graphToGraphviz (end) -}; + } // dump_graphviz (end) + + + private: + + + // ----------------------------------------- + // Helpers & Functors + // ----------------------------------------- + struct ReduceMaxFunctor + { + color_view_t colors; + ReduceMaxFunctor(color_view_t cat) : colors(cat) {} + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t& i, color_t& color_max) const + { + if(color_max < colors(i)) + color_max = colors(i); + } + + // max -plus semiring equivalent of "plus" + KOKKOS_INLINE_FUNCTION + void join(volatile color_t& dst, const volatile color_t& src) const + { + if(dst < src) + { + dst = src; + } + } + + KOKKOS_INLINE_FUNCTION + void init(color_t& dst) const { dst = 0; } + }; + + +}; // class GraphColorDistance2Handle (end) } // namespace KokkosGraph diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index b26c39f5cb..c67eae1507 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -168,7 +168,7 @@ class GraphColorDistance2MatrixSquared * algorithm to assume that the color is fixed for the corresponding vertex. * \param num_phases: The number of iterations (phases) that algorithm takes to converge. */ - virtual void execute() + virtual void compute_distance2_color() { double time = 0; Kokkos::Impl::Timer timer; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 98d9574db1..1fffd91ae3 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -201,7 +201,11 @@ class GraphColorDistance2 // GraphColorDistance2::execute() // // ----------------------------------------------------------------- - virtual void execute() + + /** + * \brief Computes the distance-2 graph coloring. + */ + virtual void compute_distance2_color() { color_view_type colors_out("Graph Colors", this->nv); @@ -245,7 +249,7 @@ class GraphColorDistance2 size_t degree_d2_max=0; size_t degree_d2_sum=0; non_const_1d_size_type_view_t degree_d2 = non_const_1d_size_type_view_t("degree d2", this->nv); - this->calculate_d2_degree(degree_d2, degree_d2_max, degree_d2_sum); + this->compute_distance2_degree(degree_d2, degree_d2_max, degree_d2_sum); if(true || _ticToc ) { prettyPrint1DView(degree_d2, "Degree D2", 150); @@ -407,22 +411,22 @@ class GraphColorDistance2 /** * Validate Distance 2 Graph Coloring * - * @param validation_flags is an array of 3 booleans. - * validation_flags[0] : True IF the distance-2 coloring is invalid. - * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. - * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices - * at distance=2 from each other has the same color. - * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. - * This may not be an INVALID coloring, but can indicate poor quality in coloring. + * @param[in] validation_flags Is an array of 3 booleans to capture if the graph coloring is invalid, and if so what is invalid. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. + * This may not be an INVALID coloring, but can indicate poor quality in coloring. * * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. */ - bool verifyDistance2Coloring(const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - bool validation_flags[]) + bool verify_coloring(const_lno_row_view_t xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + bool validation_flags[]) { bool output = true; @@ -462,18 +466,35 @@ class GraphColorDistance2 output = !h_flags[0]; return output; - } // verifyDistance2Coloring (end) + } // verify_coloring (end) + + + + /** + * Generate a histogram of the distance-2 colors + * + * @param[out] histogram A Kokkos::View that will contain the histogram. + * Must be of size num_colors+1 + * + * @return None + */ + void compute_color_histogram(nnz_lno_temp_work_view_t & histogram) + { + MyExecSpace::fence(); + KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); + } /** * Print out the histogram of colors in CSV format. */ - void printDistance2ColorsHistogramCSV() + void print_color_histogram_csv() { nnz_lno_t num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); - this->getDistance2ColorsHistogram(histogram); + this->compute_color_histogram(histogram); size_t i=0; for(i=1; i< histogram.extent(0)-1; i++) @@ -490,11 +511,11 @@ class GraphColorDistance2 * Print out the histogram of colors in a more human friendly format * This will not print out all the colors if there are many. */ - void printDistance2ColorsHistogram() + void print_color_histogram() { nnz_lno_t num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); - this->getDistance2ColorsHistogram(histogram); + this->compute_color_histogram(histogram); std::cout << ">>> Histogram: " << std::endl; KokkosKernels::Impl::kk_print_1Dview(histogram); std::cout << std::endl; @@ -505,14 +526,13 @@ class GraphColorDistance2 /** * Calculate the distance-2 degree of all the vertices in the graph. * - * @param degree_d2 : A mutable view of size |V| - * @param degree_d2_max : Saves the max distance-2 degree value in. - * @param degree_d2_sum : Saves the sum of the distance-2 degrees - * of all vertices. + * @param[out] degree_d2 A mutable view of size |V| + * @param[out] degree_d2_max Saves the max distance-2 degree value in. * * @note This is EXPERIMENTAL + * @todo Uses HashMapAccumulator and still needs a lot of tweaking to make performant. */ - void calculate_d2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) + void compute_distance2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) { // Vertex group chunking nnz_lno_t v_chunk_size = this->_chunkSize; @@ -523,7 +543,7 @@ class GraphColorDistance2 std::cout << ">>> v_num_chunks = " << v_num_chunks << std::endl; // Get the maximum distance-1 degree - nnz_lno_t max_d1_degree = this->calculate_max_degree(); + nnz_lno_t max_d1_degree = this->compute_max_distance1_degree(); // Round up hash_size to next power of two nnz_lno_t hash_size = 1; @@ -571,42 +591,10 @@ class GraphColorDistance2 - /** - * Compute the maximum distance-1 degree. - */ - nnz_lno_t calculate_max_degree() const - { - nnz_lno_t max_degree = 0; - Kokkos::parallel_reduce("Max D1 Degree", - this->nv, - KOKKOS_LAMBDA(const nnz_lno_t& vid, nnz_lno_t& lmax) - { - const nnz_lno_t degree = this->xadj(vid+1) - this->xadj(vid); - lmax = degree > lmax ? degree : lmax; - }, - Kokkos::Max(max_degree)); - return max_degree; - } - - - private: - /** - * Generate a histogram of the distance-2 colors. - * - histogram must be of size num_colors+1 - */ - void getDistance2ColorsHistogram(nnz_lno_temp_work_view_t & histogram) - { - MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); - } - - - // ----------------------------------------------------------------- // // GraphColorDistance2::colorGreedy() @@ -808,11 +796,34 @@ class GraphColorDistance2 } // resolveConflictsSerial (end) + // ------------------------------------------------------ // Functions: Helpers // ------------------------------------------------------ + + /** + * Compute the maximum distance-1 degree. + * + * @return Maximum distance1 degree in the graph + */ + nnz_lno_t compute_max_distance1_degree() const + { + nnz_lno_t max_degree = 0; + Kokkos::parallel_reduce("Max D1 Degree", + this->nv, + KOKKOS_LAMBDA(const nnz_lno_t& vid, nnz_lno_t& lmax) + { + const nnz_lno_t degree = this->xadj(vid+1) - this->xadj(vid); + lmax = degree > lmax ? degree : lmax; + }, + Kokkos::Max(max_degree)); + return max_degree; + } + + + // pretty-print a 1D View with label template void prettyPrint1DView(kokkos_view_t &view, const char *label, const size_t max_entries = 500) const @@ -842,7 +853,6 @@ class GraphColorDistance2 - public: // ------------------------------------------------------ // Functors: Distance-2 Graph Coloring // ------------------------------------------------------ diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index c241736323..6bd3446012 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -518,7 +518,7 @@ void // WCMCLEN: SCAFFOLDING / EXPERIMENTAL // handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); - // KokkosGraph::Experimental::graph_color_distance2 + // KokkosGraph::Experimental::graph_compute_distance2_color // (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); original_num_colors = handle->get_graph_coloring_handle()->get_num_colors(); diff --git a/unit_test/graph/Test_Graph_graph_color_distance2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp index f02966841d..7b70be0e47 100644 --- a/unit_test/graph/Test_Graph_graph_color_distance2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -93,13 +93,8 @@ run_graphcolor_d2(crsMat_type const size_t num_rows_1 = input_mat.numRows(); const size_t num_cols_1 = input_mat.numCols(); - graph_color_distance2(&kh, - num_rows_1, - num_cols_1, - input_mat.graph.row_map, - input_mat.graph.entries, - input_mat.graph.row_map, - input_mat.graph.entries); + graph_compute_distance2_color + (&kh, num_rows_1, num_cols_1, input_mat.graph.row_map, input_mat.graph.entries, input_mat.graph.row_map, input_mat.graph.entries); num_colors = kh.get_distance2_graph_coloring_handle()->get_num_colors(); vertex_colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); From f1adf350fe68c8a1e4322692bbdc6f63ceca3fba Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 22 Jan 2019 17:39:07 -0700 Subject: [PATCH 094/190] D2 Coloring: Fixing CUDA issues --- .../KokkosGraph_GraphColorDistance2Handle.hpp | 9 ++++++- .../impl/KokkosGraph_Distance2Color_impl.hpp | 25 ++++++++++++------- 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index 0d0f77e0fd..89b4060f5a 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -428,8 +428,15 @@ class GraphColorDistance2Handle // ----------------------------------------- - // Helpers & Functors + // Helpers // ----------------------------------------- + + // ----------------------------------------- + // Functors + // ----------------------------------------- + + public: + struct ReduceMaxFunctor { color_view_t colors; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 1fffd91ae3..c5a8c32854 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -324,8 +324,8 @@ class GraphColorDistance2 time = timer.seconds(); total_time += time; std::cout << "\tIteration: " << iter << std::endl - << "\t - Time speculative greedy phase : " << time << std::endl; - std::cout << "\t - Num Uncolored : " << numUncolored << std::endl; + << "\t - Time speculative greedy phase : " << time << std::endl + << "\t - Num Uncolored (greedy-color) : " << numUncolored << std::endl; gc_handle->add_to_overall_coloring_time_phase1(time); @@ -357,7 +357,7 @@ class GraphColorDistance2 time = timer.seconds(); total_time += time; std::cout << "\t - Time conflict detection : " << time << std::endl; - std::cout << "\t - Num Uncolored : " << numUncolored << std::endl; + std::cout << "\t - Num Uncolored (conflicts) : " << numUncolored << std::endl; gc_handle->add_to_overall_coloring_time_phase2(time); timer.reset(); } @@ -480,9 +480,10 @@ class GraphColorDistance2 */ void compute_color_histogram(nnz_lno_temp_work_view_t & histogram) { + KokkosKernels::Impl::kk_get_histogram + (this->nv, this->gc_handle->get_vertex_colors(), histogram); + MyExecSpace::fence(); - KokkosKernels::Impl::kk_get_histogram(this->nv, this->gc_handle->get_vertex_colors(), histogram); } @@ -493,15 +494,20 @@ class GraphColorDistance2 void print_color_histogram_csv() { nnz_lno_t num_colors = this->gc_handle->get_num_colors(); + nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); + this->compute_color_histogram(histogram); + nnz_lno_temp_work_view_t::HostMirror h_histogram = Kokkos::create_mirror_view(histogram); + Kokkos::deep_copy(h_histogram, histogram); + size_t i=0; - for(i=1; i< histogram.extent(0)-1; i++) + for(i=1; i< h_histogram.extent(0)-1; i++) { - std::cout << histogram(i) << ","; + std::cout << h_histogram(i) << ","; } - std::cout << histogram(i); + std::cout << h_histogram(i); } @@ -802,6 +808,8 @@ class GraphColorDistance2 // ------------------------------------------------------ + public: + /** * Compute the maximum distance-1 degree. @@ -1418,7 +1426,6 @@ class GraphColorDistance2 { has_invalid_color = true; break_out = true; - std::cout << ">>> Invalid color match: " << vid << ", " << vid_d2 << " both have color " << color_vid << std::endl; } } } From 42a3edafdb1b20af895db2c6ab3271cb128f783e Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 22 Jan 2019 18:14:45 -0700 Subject: [PATCH 095/190] D2 Coloring: Fixed CUDA runtime error --- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index c5a8c32854..7c34fd86c6 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -499,7 +499,7 @@ class GraphColorDistance2 this->compute_color_histogram(histogram); - nnz_lno_temp_work_view_t::HostMirror h_histogram = Kokkos::create_mirror_view(histogram); + auto h_histogram = Kokkos::create_mirror_view(histogram); Kokkos::deep_copy(h_histogram, histogram); size_t i=0; @@ -508,7 +508,6 @@ class GraphColorDistance2 std::cout << h_histogram(i) << ","; } std::cout << h_histogram(i); - } @@ -750,13 +749,13 @@ class GraphColorDistance2 h_recolor_list = Kokkos::create_mirror_view(current_vertexList_); Kokkos::deep_copy(h_recolor_list, current_vertexList_); - color_host_view_t h_colors = Kokkos::create_mirror_view(vertex_colors_); + auto h_colors = Kokkos::create_mirror_view(vertex_colors_); - typename const_lno_row_view_t::HostMirror h_idx = Kokkos::create_mirror_view(xadj_); - typename adj_view_t::HostMirror h_adj = Kokkos::create_mirror_view(adj_); + auto h_idx = Kokkos::create_mirror_view(xadj_); + auto h_adj = Kokkos::create_mirror_view(adj_); - typename const_clno_row_view_t::HostMirror h_t_idx = Kokkos::create_mirror_view(t_xadj_); - typename const_clno_nnz_view_t::HostMirror h_t_adj = Kokkos::create_mirror_view(t_adj_); + auto h_t_idx = Kokkos::create_mirror_view(t_xadj_); + auto h_t_adj = Kokkos::create_mirror_view(t_adj_); Kokkos::deep_copy(h_colors, vertex_colors_); From fb271ae915f897ada40668af297ac06d05bce2e3 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 23 Jan 2019 11:22:06 -0700 Subject: [PATCH 096/190] Distance-2 Graph Coloring cleanup --- perf_test/graph/KokkosGraph_color_d2.cpp | 87 +++++++++---------- .../impl/KokkosGraph_Distance2Color_impl.hpp | 4 +- 2 files changed, 42 insertions(+), 49 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index eea8908d81..d018d5798c 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -63,7 +63,7 @@ #include #include #include -#include // EXPERIMENTAL (WCMCLEN) +#include using namespace KokkosGraph; @@ -92,6 +92,10 @@ using namespace KokkosGraph; #endif #endif +// Toggle EXPERIMENTAL code for calculating +// a tight bound on distance-2 degree. +#define USE_EXPERIMENTAL_MAXD2DEGREE 0 + using namespace KokkosGraph; @@ -354,7 +358,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) break; } - std::cout << ">>> Run Graph Color D2 (" << label_algorithm << ")" << std::endl; + std::cout << std::endl << "Run Graph Color D2 (" << label_algorithm << ")" << std::endl; // If any of the runs have an invalid result, this will be set to false. bool all_results_valid = true; @@ -387,28 +391,28 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // Verify correctness // ------------------------------------------ bool d2_coloring_is_valid = false; - bool d2_coloring_validation_flags[4] = {false}; + bool d2_coloring_validation_flags[4] = { false }; d2_coloring_is_valid = graph_verify_distance2_color(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, d2_coloring_validation_flags); // Print out messages based on coloring validation check. if(d2_coloring_is_valid) { - std::cout << std::endl << ">>> Distance-2 Graph Coloring is VALID" << std::endl << std::endl; + std::cout << std::endl << "Distance-2 Graph Coloring is VALID" << std::endl << std::endl; } else { all_results_valid = false; std::cout << std::endl - << ">>> Distance-2 Graph Coloring is NOT VALID" << std::endl - << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl - << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl + << "Distance-2 Graph Coloring is NOT VALID" << std::endl + << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl + << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl << std::endl; } if(d2_coloring_validation_flags[3]) { - std::cout << ">>> Distance-2 Graph Coloring may have poor quality." << std::endl - << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl + std::cout << "Distance-2 Graph Coloring may have poor quality." << std::endl + << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl << std::endl; } @@ -426,7 +430,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) Kokkos::Impl::Timer timer; - #if 0 + #if defined(USE_EXPERIMENTAL_MAXD2DEGREE) && USE_EXPERIMENTAL_MAXD2DEGREE double time_d2_degree; timer.reset(); @@ -485,16 +489,18 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "Summary" << std::endl << "-------" << std::endl - //<< " Date/Time : " << currentDateTimeStr << std::endl + << " Date/Time : " << currentDateTimeStr << std::endl << " KExecSName : " << Kokkos::DefaultExecutionSpace::name() << std::endl << " Filename : " << a_mtx_bin_file << std::endl << " Num Verts : " << crsGraph.numRows() << std::endl << " Num Edges : " << crsGraph.entries.dimension_0() << std::endl << " Concurrency : " << Kokkos::DefaultExecutionSpace::concurrency() << std::endl << " Algorithm : " << label_algorithm << std::endl - // << "Graph Stats" << std::endl - // << " Degree D2 Max : " << degree_d2_max << std::endl - // << " Degree D2 Time : " << time_d2_degree << std::endl + #if defined(USE_EXPERIMENTAL_MAXD2DEGREE) && USE_EXPERIMENTAL_MAXD2DEGREE + << "Graph Stats" << std::endl + << " Degree D2 Max : " << degree_d2_max << std::endl + << " Degree D2 Time : " << time_d2_degree << std::endl + #endif << "Overall Time/Stats" << std::endl << " Total Time : " << total_time << std::endl << " Avg Time : " << avg_time << std::endl @@ -514,7 +520,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVTIMEHDR" << "," << "Filename" << "," << "Host" - //<< "," << "DateTime" + << "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -527,17 +533,19 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << "Total Time CG" << "," << "Total Time FC" << "," << "Total Time RC" - // << "," << "Time D2 Degree" << "," << "Avg Colors" << "," << "Avg Num Phases" - // << "," << "Degree D2 Max" + #if defined(USE_EXPERIMENTAL_MAXD2DEGREE) && USE_EXPERIMENTAL_MAXD2DEGREE + << "," << "Time D2 Degree" + << "," << "Degree D2 Max" + #endif << "," << "Validation" << std::endl; std::cout << "CSVTIMEDATA" << "," << a_mtx_bin_file << "," << hostname - //<< "," << currentDateTimeStr + << "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -550,17 +558,20 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << total_time_color_greedy << "," << total_time_find_conflicts << "," << total_time_resolve_conflicts - // << "," << time_d2_degree + << "," << avg_colors << "," << avg_phases - // << "," << degree_d2_max + #if defined(USE_EXPERIMENTAL_MAXD2DEGREE) && USE_EXPERIMENTAL_MAXD2DEGREE + << "," << time_d2_degree + << "," << degree_d2_max + #endif << "," << all_results_valid_str << std::endl; std::cout << "CSVHISTHDR" << "," << "Filename" << "," << "Host" - //<< "," << "DateTime" + << "," << "DateTime" << "," << "Num Rows" << "," << "Num Edges" << "," << "Execution Space" @@ -572,7 +583,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) std::cout << "CSVHISTDATA" << "," << a_mtx_bin_file << "," << hostname - //<< "," << currentDateTimeStr + << "," << currentDateTimeStr << "," << crsGraph.numRows() << "," << crsGraph.entries.dimension_0() << "," << Kokkos::DefaultExecutionSpace::name() @@ -589,21 +600,19 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) template void run_multi_mem_experiment(Parameters params) { + using myExecSpace = exec_space; + using myFastDevice = Kokkos::Device; + using mySlowExecSpace = Kokkos::Device; + using fast_crstmat_t = typename MyKokkosSparse::CrsMatrix; + using fast_graph_t = typename fast_crstmat_t::StaticCrsGraphType; - typedef exec_space myExecSpace; - typedef Kokkos::Device myFastDevice; - typedef Kokkos::Device mySlowExecSpace; - - typedef typename MyKokkosSparse::CrsMatrix fast_crstmat_t; - typedef typename fast_crstmat_t::StaticCrsGraphType fast_graph_t; // typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; // typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; - // typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; // typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; - typedef typename MyKokkosSparse::CrsMatrix slow_crstmat_t; - typedef typename slow_crstmat_t::StaticCrsGraphType slow_graph_t; + using slow_crstmat_t = typename MyKokkosSparse::CrsMatrix; + using slow_graph_t = typename slow_crstmat_t::StaticCrsGraphType; // typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; // typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; @@ -847,22 +856,6 @@ int main(int argc, char *argv[]) } #endif - /* - // Timer products. - struct timeval begin, end; - - gettimeofday(&begin, NULL); - - std::cout << "Do stuff here!" << std::endl; - - gettimeofday(&end, NULL); - - // Calculate time. - double time = 1.0 * (end.tv_sec - begin.tv_sec) + 1.0e-6 * (end.tv_usec - begin.tv_usec); - - std::cout << "Time: " << time << std::endl; - */ - Kokkos::finalize(); return 0; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 7c34fd86c6..742fb1f75f 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -521,7 +521,7 @@ class GraphColorDistance2 nnz_lno_t num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); this->compute_color_histogram(histogram); - std::cout << ">>> Histogram: " << std::endl; + std::cout << "Distance-2 Color Histogram: " << std::endl; KokkosKernels::Impl::kk_print_1Dview(histogram); std::cout << std::endl; } @@ -534,7 +534,7 @@ class GraphColorDistance2 * @param[out] degree_d2 A mutable view of size |V| * @param[out] degree_d2_max Saves the max distance-2 degree value in. * - * @note This is EXPERIMENTAL + * @note This is EXPERIMENTAL development code. * @todo Uses HashMapAccumulator and still needs a lot of tweaking to make performant. */ void compute_distance2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) From 9bc9fb629f99dc82defcd6506be98b8a716eb652 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 23 Jan 2019 15:38:06 -0700 Subject: [PATCH 097/190] D2 Coloring cleanup: graphviz output cleanup --- .../KokkosGraph_GraphColorDistance2Handle.hpp | 91 ++++++++++++++----- src/graph/KokkosGraph_GraphColorHandle.hpp | 70 -------------- 2 files changed, 68 insertions(+), 93 deletions(-) diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index 89b4060f5a..d7543f2362 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -72,10 +72,15 @@ class GraphColorDistance2Handle { public: - typedef ExecutionSpace HandleExecSpace; - typedef TemporaryMemorySpace HandleTempMemorySpace; - typedef PersistentMemorySpace HandlePersistentMemorySpace; + using HandleExecSpace = ExecutionSpace; + //typedef ExecutionSpace HandleExecSpace; + + using HandleTempMemorySpace = TemporaryMemorySpace; + //typedef TemporaryMemorySpace HandleTempMemorySpace; + + using HandlePersistentMemorySpace = PersistentMemorySpace; + //typedef PersistentMemorySpace HandlePersistentMemorySpace; typedef typename std::remove_const::type size_type; typedef const size_type const_size_type; @@ -146,7 +151,7 @@ class GraphColorDistance2Handle /** - * \brief Default constructor. + * Default constructor */ GraphColorDistance2Handle() : coloring_algorithm_type(COLORING_D2_DEFAULT) @@ -173,16 +178,20 @@ class GraphColorDistance2Handle } - /** Changes the graph coloring algorithm. - * @param[in] col_algo Coloring algorithm, one of: - * - COLORING_D2_DEFAULT - * - COLORING_D2_SERIAL - * - COLORING_D2_MATRIX_SQUARED - * - COLORING_D2_VB - * - COLORING_D2_VB_BIT - * - COLORING_D2_VB_BIT_EF + /** + * Changes the graph coloring algorithm. + * + * @param[in] col_algo Coloring algorithm, one of: + * - COLORING_D2_DEFAULT + * - COLORING_D2_SERIAL + * - COLORING_D2_MATRIX_SQUARED + * - COLORING_D2_VB + * - COLORING_D2_VB_BIT + * - COLORING_D2_VB_BIT_EF * * @param[in] set_default_parameters Whether or not to reset the default parameters for the given algorithm. + * Default = true. + * * @return None */ void set_algorithm(const GraphColoringAlgorithmDistance2 &col_algo, bool set_default_parameters = true) @@ -357,10 +366,14 @@ class GraphColorDistance2Handle } - /** Print / write out the graph in a GraphVIZ format. - * Color "1" will be rendered as a red circle. - * Color "0" (uncolored) will be a star shape. - * Other node colors shown as just the color value. + /** + * Print / write out the graph in a GraphVIZ format. + * + * - Nodes colored with 1-5 will be filled in with some colors. + * - Nodes colored > 5 will be unfilled (i.e., white background). + * - Nodes colored with 0 (i.e., uncolored) will be filled in with red + * and will have a dashed border line. Uncolored nodes indicate a failed + * coloring. * * @param[in] os use std::cout for output to STDOUT stream, or a ofstream object * (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write @@ -398,18 +411,50 @@ class GraphColorDistance2Handle for(size_t vid = 0; vid < num_verts; vid++) { + // Set color scheme for colors 1-5 + std::string fillcolor = ""; + std::string penwidth = ""; + std::string color = ""; + std::string style = ""; + std::string fontcolor = ""; if(1 == h_colors(vid)) { - os << " " << vid << " [ label=\"\", shape=circle, style=filled, color=red, fillcolor=red];" << std::endl; + fillcolor = ", fillcolor=\"#CC4C51\""; + style = ", style=\"filled\""; } - else if(0 == h_colors(vid)) + else if(2 == h_colors(vid)) + { + fillcolor = ", fillcolor=\"#CEBA5A\""; + style = ", style=\"filled\""; + } + else if(3 == h_colors(vid)) { - os << " " << vid << " [ label=\"" << vid << "\", shape=star, style=filled, color=black];" << std::endl; + fillcolor = ", fillcolor=\"#838FA4\""; + style = ", style=\"filled\""; } - else + else if(4 == h_colors(vid)) { - os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; + fillcolor = ", fillcolor=\"#C3AD86\""; + style = ", style=\"filled\""; } + else if(5 == h_colors(vid)) + { + fillcolor = ", fillcolor=\"#935C44\""; + style = ", style=\"filled\""; + } + else if(0 == h_colors(vid)) + { + style = ", style=\"filled,dashed\""; + fillcolor = ", fillcolor=\"red\""; + fontcolor = ", fontcolor=\"black\""; + color = ", color=\"black\""; + penwidth = ", penwidth=\"2.0\""; + } + + os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"" << style << fontcolor << color + << fillcolor << penwidth << "];" << std::endl; + + // Add the node's edges for(size_t iadj = h_rowmap(vid); iadj < (size_t)h_rowmap(vid + 1); iadj++) { size_t vadj = h_entries(iadj); @@ -430,11 +475,11 @@ class GraphColorDistance2Handle // ----------------------------------------- // Helpers // ----------------------------------------- - + // ----------------------------------------- // Functors // ----------------------------------------- - + public: struct ReduceMaxFunctor diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index febe0afdd1..363831c7c8 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -712,76 +712,6 @@ class GraphColoringHandle this->num_colors = 0; } - - // Print / write out the graph in a GraphVIZ format. - // Color "1" will be rendered as a red circle. - // Color "0" (uncolored) will be a star shape. - // Other node colors shown as just the color value. - // - // @param os use std::cout for output to STDOUT stream, or a ofstream object - // (i.e., `std::ofstream os("G.dot", std::ofstream::out);`) to write - // to a file. - template - void graphToGraphviz(std::ostream &os, - const index_t num_verts, - rowmap_t &rowmap, - entries_t &entries, - kokkos_view_t &colors) const - { - typedef typename kokkos_view_t::HostMirror h_colors_t; - typedef typename rowmap_t::HostMirror h_rowmap_t; - typedef typename entries_t::HostMirror h_entries_t; - - h_colors_t h_colors = Kokkos::create_mirror_view(colors); - Kokkos::deep_copy(h_colors, colors); - - h_rowmap_t h_rowmap = Kokkos::create_mirror_view(rowmap); - Kokkos::deep_copy(h_rowmap, rowmap); - - h_entries_t h_entries = Kokkos::create_mirror_view(entries); - Kokkos::deep_copy(h_entries, entries); - - - os << "Graph G" << std::endl - << "{" << std::endl - << " rankdir=LR;" << std::endl - << " overlap=false;" << std::endl - << " splines=true;" << std::endl - << " maxiter=2000;" << std::endl - << " node [shape=Mrecord];" << std::endl - << " edge [len=2.0];" << std::endl - << std::endl; - - for(index_t vid = 0; vid < num_verts; vid++) - { - if(1 == h_colors(vid)) - { - os << " " << vid << " [ label=\"\", shape=circle, style=filled, color=red, fillcolor=red];" << std::endl; - } - else if(0 == h_colors(vid)) - { - os << " " << vid << " [ label=\"" << vid << "\", shape=star, style=filled, color=black];" << std::endl; - } - else - { - os << " " << vid << " [ label=\"" << vid << "|" << h_colors(vid) << "\"];" << std::endl; - } - for(index_t iadj = h_rowmap(vid); iadj < h_rowmap(vid + 1); iadj++) - { - index_t vadj = h_entries(iadj); - if(vadj >= vid) - { - os << " " << vid << " -- " << vadj << ";" << std::endl; - } - } - os << std::endl; - } - os << "}" << std::endl; - } // graphToGraphviz (end) - - - - }; } // namespace KokkosGraph From 4103c3e39afc4e8c0c3274d94d932be01601f011 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 23 Jan 2019 18:38:30 -0700 Subject: [PATCH 098/190] D2Coloring: Checkpoint --- perf_test/graph/KokkosGraph_color_d2.cpp | 2 +- src/graph/KokkosGraph_Distance2Color.hpp | 2 +- .../KokkosGraph_GraphColorDistance2Handle.hpp | 224 +++-- ...raph_Distance2Color_MatrixSquared_impl.hpp | 103 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 880 +++++++++--------- 5 files changed, 626 insertions(+), 585 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index d018d5798c..2ad3bc4d42 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -379,7 +379,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) KokkosKernels::Impl::print_1Dview(kh.get_distance2_graph_coloring_handle()->get_vertex_colors()); std::cout << std::endl; - // If verbose mode is on and there the graph has fewer than 1000 verts, dump a GraphVIZ DOT file. + // If verbose mode is on and there the graph has fewer than 1500 verts, dump a GraphVIZ DOT file. if(verbose && repeat==i+1 && crsGraph.numRows() < 1500) { auto colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 2696d54360..c7b998b304 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -94,7 +94,7 @@ void graph_compute_distance2_color(KernelHandle *handle, GraphColoringAlgorithmDistance2 algorithm = gch_d2->get_coloring_algo_type(); // Create a view to save the colors to. - using color_view_type = typename KernelHandle::GraphColorDistance2HandleType::color_view_t; + using color_view_type = typename KernelHandle::GraphColorDistance2HandleType::color_view_type; color_view_type colors_out("Graph Colors", num_rows); switch(algorithm) diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index d7543f2362..d2d49951e5 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -67,68 +67,55 @@ enum GraphColoringAlgorithmDistance2 -template +template class GraphColorDistance2Handle { public: - - using HandleExecSpace = ExecutionSpace; - //typedef ExecutionSpace HandleExecSpace; - - using HandleTempMemorySpace = TemporaryMemorySpace; - //typedef TemporaryMemorySpace HandleTempMemorySpace; - - using HandlePersistentMemorySpace = PersistentMemorySpace; - //typedef PersistentMemorySpace HandlePersistentMemorySpace; - - typedef typename std::remove_const::type size_type; - typedef const size_type const_size_type; - - typedef typename std::remove_const::type nnz_lno_t; - typedef const nnz_lno_t const_nnz_lno_t; - - typedef typename std::remove_const::type color_t; - typedef const color_t const_color_t; - - typedef typename Kokkos::View color_view_t; - - typedef typename color_view_t::array_layout color_view_array_layout; - typedef typename color_view_t::device_type color_view_device_t; - typedef typename color_view_t::memory_traits color_view_memory_traits; - typedef typename color_view_t::HostMirror color_host_view_t; // Host view type - - - typedef typename Kokkos::View size_type_temp_work_view_t; - typedef typename Kokkos::View size_type_persistent_work_view_t; - - typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; // Host view type - - typedef typename Kokkos::View nnz_lno_temp_work_view_t; - typedef typename Kokkos::View nnz_lno_persistent_work_view_t; - typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; // Host view type - - typedef Kokkos::TeamPolicy team_policy_t; - typedef typename team_policy_t::member_type team_member_t; - - typedef typename Kokkos::View non_const_1d_size_type_view_t; + using HandleExecSpace = ExecutionSpace; + using HandleTempMemorySpace = TemporaryMemorySpace; + using HandlePersistentMemorySpace = PersistentMemorySpace; + using size_type = typename std::remove_const::type; + using const_size_type = const size_type; + using nnz_lno_type = typename std::remove_const::type; + using const_nnz_lno_type = const nnz_lno_type; + using color_type = typename std::remove_const::type; + using const_color_type = const color_type; + using color_view_type = typename Kokkos::View; + using color_view_array_layout = typename color_view_type::array_layout; + using color_view_device_type = typename color_view_type::device_type; + using color_view_memory_traits = typename color_view_type::memory_traits; + using color_host_view_type = typename color_view_type::HostMirror; + using size_type_temp_work_view_type = typename Kokkos::View; + using size_type_persistent_work_view_type = typename Kokkos::View; + using size_type_persistent_work_host_view_type = typename size_type_persistent_work_view_type::HostMirror; + using nnz_lno_temp_work_view_type = typename Kokkos::View; + using nnz_lno_persistent_work_view_type = typename Kokkos::View; + using nnz_lno_persistent_work_host_view_type = typename nnz_lno_persistent_work_view_type::HostMirror; + using team_policy_type = Kokkos::TeamPolicy; + using team_member_type = typename team_policy_type::member_type; + using non_const_1d_size_type_view_type = typename Kokkos::View; private: - // Parameters GraphColoringAlgorithmDistance2 coloring_algorithm_type; // Which algorithm type to use. - bool verbose; // verbosity flag - bool tictoc; // print time at every step + bool verbose; // verbosity flag + bool tictoc; // print time at every step - bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. + bool vb_edge_filtering; // whether to do edge filtering or not in vertex based algorithms. - int vb_chunk_size; // the (minimum) size of the consecutive works that a thread will be assigned to. - int max_number_of_iterations; // maximum allowed number of phases that + int vb_chunk_size; // the (minimum) size of the consecutive works that a thread will be assigned to. + int max_number_of_iterations; // maximum allowed number of phases that // STATISTICS - double overall_coloring_time; // the overall time that it took to color the graph. In the case of the iterative calls. + double overall_coloring_time; // The overall time taken to color the graph. In the case of the iterative calls. double overall_coloring_time_phase1; // double overall_coloring_time_phase2; // double overall_coloring_time_phase3; // Some timer accumulators for internal phases. @@ -136,20 +123,18 @@ class GraphColorDistance2Handle double overall_coloring_time_phase5; // double coloring_time; // the time that it took to color the graph - int num_phases; // Number of phases used by the coloring algorithm + int num_phases; // Number of phases used by the coloring algorithm - size_type size_of_edge_list; // todo not used? + size_type size_of_edge_list; // todo not used? - color_view_t vertex_colors; - bool is_coloring_called_before; - nnz_lno_t num_colors; + color_view_type vertex_colors; + bool is_coloring_called_before; + nnz_lno_type num_colors; public: - - /** * Default constructor */ @@ -194,7 +179,7 @@ class GraphColorDistance2Handle * * @return None */ - void set_algorithm(const GraphColoringAlgorithmDistance2 &col_algo, bool set_default_parameters = true) + void set_algorithm(const GraphColoringAlgorithmDistance2& col_algo, bool set_default_parameters = true) { if(col_algo == COLORING_D2_DEFAULT) { @@ -221,64 +206,65 @@ class GraphColorDistance2Handle */ void choose_default_algorithm() { - #if defined(KOKKOS_ENABLE_SERIAL) +#if defined(KOKKOS_ENABLE_SERIAL) if(Kokkos::Impl::is_same::value) { this->coloring_algorithm_type = COLORING_D2_SERIAL; - #ifdef VERBOSE +#ifdef VERBOSE std::cout << "Serial Execution Space, Default Algorithm: COLORING_VB" << std::endl; - #endif +#endif } - #endif +#endif - #if defined(KOKKOS_ENABLE_THREADS) +#if defined(KOKKOS_ENABLE_THREADS) if(Kokkos::Impl::is_same::value) { this->coloring_algorithm_type = COLORING_D2_VB_BIT; - #ifdef VERBOSE +#ifdef VERBOSE std::cout << "PTHREAD Execution Space, Default Algorithm: COLORING_VB" << std::endl; - #endif +#endif } - #endif +#endif - #if defined(KOKKOS_ENABLE_OPENMP) +#if defined(KOKKOS_ENABLE_OPENMP) if(Kokkos::Impl::is_same::value) { this->coloring_algorithm_type = COLORING_D2_VB_BIT; - #ifdef VERBOSE +#ifdef VERBOSE std::cout << "OpenMP Execution Space, Default Algorithm: COLORING_VB" << std::endl; - #endif +#endif } - #endif +#endif - #if defined(KOKKOS_ENABLE_CUDA) +#if defined(KOKKOS_ENABLE_CUDA) if(Kokkos::Impl::is_same::value) { this->coloring_algorithm_type = COLORING_D2_VB_BIT; - #ifdef VERBOSE +#ifdef VERBOSE std::cout << "Cuda Execution Space, Default Algorithm: COLORING_VB" << std::endl; - #endif +#endif } - #endif +#endif - #if defined(KOKKOS_ENABLE_QTHREAD) +#if defined(KOKKOS_ENABLE_QTHREAD) if(Kokkos::Impl::is_same::value) { this->coloring_algorithm_type = COLORING_D2_VB_BIT; - #ifdef VERBOSE +#ifdef VERBOSE std::cout << "Qthread Execution Space, Default Algorithm: COLORING_VB" << std::endl; - #endif +#endif } - #endif +#endif } - nnz_lno_t get_num_colors() + nnz_lno_type get_num_colors() { if(num_colors == 0) { typedef typename Kokkos::RangePolicy my_exec_space; - Kokkos::parallel_reduce("KokkosKernels::FindMax", my_exec_space(0, vertex_colors.extent(0)), ReduceMaxFunctor(vertex_colors), num_colors); + Kokkos::parallel_reduce( + "KokkosKernels::FindMax", my_exec_space(0, vertex_colors.extent(0)), ReduceMaxFunctor(vertex_colors), num_colors); } return num_colors; } @@ -286,7 +272,7 @@ class GraphColorDistance2Handle /** \brief Sets Default Parameter settings for the given algorithm. */ - void set_defaults(const GraphColoringAlgorithmDistance2 &col_algo) + void set_defaults(const GraphColoringAlgorithmDistance2& col_algo) { switch(col_algo) { @@ -296,10 +282,10 @@ class GraphColorDistance2Handle case COLORING_D2_VB: case COLORING_D2_VB_BIT: case COLORING_D2_VB_BIT_EF: - this->tictoc = false; - this->vb_edge_filtering = false; - this->vb_chunk_size = 8; - this->max_number_of_iterations = 200; + this->tictoc = false; + this->vb_edge_filtering = false; + this->vb_chunk_size = 8; + this->max_number_of_iterations = 200; break; default: throw std::runtime_error("Unknown Distance-2 Graph Coloring Algorithm\n"); @@ -310,17 +296,17 @@ class GraphColorDistance2Handle /** * \brief Destructor */ - virtual ~GraphColorDistance2Handle(){}; + virtual ~GraphColorDistance2Handle() {}; // getters and setters GraphColoringAlgorithmDistance2 get_coloring_algo_type() const { return this->coloring_algorithm_type; } - bool get_verbose() const { return this->verbose; } - double get_coloring_time() const { return this->coloring_time; } + bool get_verbose() const { return this->verbose; } + double get_coloring_time() const { return this->coloring_time; } int get_max_number_of_iterations() const { return this->max_number_of_iterations; } - int get_num_phases() const { return this->num_phases; } + int get_num_phases() const { return this->num_phases; } - double get_overall_coloring_time() const { return this->overall_coloring_time; } + double get_overall_coloring_time() const { return this->overall_coloring_time; } double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } @@ -329,36 +315,51 @@ class GraphColorDistance2Handle bool get_tictoc() const { return this->tictoc; } - int get_vb_chunk_size() const { return this->vb_chunk_size; } + int get_vb_chunk_size() const { return this->vb_chunk_size; } bool get_vb_edge_filtering() const { return this->vb_edge_filtering; } - color_view_t get_vertex_colors() const { return this->vertex_colors; } + color_view_type get_vertex_colors() const { return this->vertex_colors; } bool is_coloring_called() const { return this->is_coloring_called_before; } // setters - void set_coloring_algo_type(const GraphColoringAlgorithmDistance2 &col_algo) { this->coloring_algorithm_type = col_algo; } + void set_coloring_algo_type(const GraphColoringAlgorithmDistance2& col_algo) { this->coloring_algorithm_type = col_algo; } - void set_verbose(const bool verbose_) { this->verbose = verbose_; } - void set_coloring_time(const double &coloring_time_) { this->coloring_time = coloring_time_; } - void set_max_number_of_iterations(const int &max_phases) { this->max_number_of_iterations = max_phases; } - void set_num_phases(const double &num_phases_) { this->num_phases = num_phases_; } + void set_verbose(const bool verbose_) { this->verbose = verbose_; } + void set_coloring_time(const double& coloring_time_) { this->coloring_time = coloring_time_; } + void set_max_number_of_iterations(const int& max_phases) { this->max_number_of_iterations = max_phases; } + void set_num_phases(const double& num_phases_) { this->num_phases = num_phases_; } - void add_to_overall_coloring_time(const double &coloring_time_) { this->overall_coloring_time += coloring_time_; } - void add_to_overall_coloring_time_phase1(const double &coloring_time_) { this->overall_coloring_time_phase1 += coloring_time_; } - void add_to_overall_coloring_time_phase2(const double &coloring_time_) { this->overall_coloring_time_phase2 += coloring_time_; } - void add_to_overall_coloring_time_phase3(const double &coloring_time_) { this->overall_coloring_time_phase3 += coloring_time_; } - void add_to_overall_coloring_time_phase4(const double &coloring_time_) { this->overall_coloring_time_phase4 += coloring_time_; } - void add_to_overall_coloring_time_phase5(const double &coloring_time_) { this->overall_coloring_time_phase5 += coloring_time_; } + void add_to_overall_coloring_time(const double& coloring_time_) { this->overall_coloring_time += coloring_time_; } + void add_to_overall_coloring_time_phase1(const double& coloring_time_) + { + this->overall_coloring_time_phase1 += coloring_time_; + } + void add_to_overall_coloring_time_phase2(const double& coloring_time_) + { + this->overall_coloring_time_phase2 += coloring_time_; + } + void add_to_overall_coloring_time_phase3(const double& coloring_time_) + { + this->overall_coloring_time_phase3 += coloring_time_; + } + void add_to_overall_coloring_time_phase4(const double& coloring_time_) + { + this->overall_coloring_time_phase4 += coloring_time_; + } + void add_to_overall_coloring_time_phase5(const double& coloring_time_) + { + this->overall_coloring_time_phase5 += coloring_time_; + } void set_tictoc(const bool use_tictoc) { this->tictoc = use_tictoc; } - void set_vb_chunk_size(const int &chunksize) { this->vb_chunk_size = chunksize; } + void set_vb_chunk_size(const int& chunksize) { this->vb_chunk_size = chunksize; } - void set_vb_edge_filtering(const bool &use_vb_edge_filtering) { this->vb_edge_filtering = use_vb_edge_filtering; } + void set_vb_edge_filtering(const bool& use_vb_edge_filtering) { this->vb_edge_filtering = use_vb_edge_filtering; } - void set_vertex_colors(const color_view_t vertex_colors_) + void set_vertex_colors(const color_view_type vertex_colors_) { this->vertex_colors = vertex_colors_; this->is_coloring_called_before = true; @@ -470,8 +471,6 @@ class GraphColorDistance2Handle private: - - // ----------------------------------------- // Helpers // ----------------------------------------- @@ -481,14 +480,13 @@ class GraphColorDistance2Handle // ----------------------------------------- public: - struct ReduceMaxFunctor { - color_view_t colors; - ReduceMaxFunctor(color_view_t cat) : colors(cat) {} + color_view_type colors; + ReduceMaxFunctor(color_view_type cat) : colors(cat) {} KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t& i, color_t& color_max) const + void operator()(const nnz_lno_type& i, color_type& color_max) const { if(color_max < colors(i)) color_max = colors(i); @@ -496,7 +494,7 @@ class GraphColorDistance2Handle // max -plus semiring equivalent of "plus" KOKKOS_INLINE_FUNCTION - void join(volatile color_t& dst, const volatile color_t& src) const + void join(volatile color_type& dst, const volatile color_type& src) const { if(dst < src) { @@ -505,11 +503,11 @@ class GraphColorDistance2Handle } KOKKOS_INLINE_FUNCTION - void init(color_t& dst) const { dst = 0; } + void init(color_type& dst) const { dst = 0; } }; -}; // class GraphColorDistance2Handle (end) +}; // class GraphColorDistance2Handle (end) } // namespace KokkosGraph diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index c67eae1507..23cd63b955 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -75,48 +75,40 @@ template single_dim_index_view_type; - - typedef Kokkos::RangePolicy my_exec_space; + using in_lno_row_view_type = lno_row_view_t_; + using in_lno_nnz_view_type = lno_nnz_view_t_; + using color_type = typename HandleType::GraphColorDistance2HandleType::color_type; + using color_view_type = typename HandleType::GraphColorDistance2HandleType::color_view_type; + using size_type = typename HandleType::size_type; + using const_size_type = typename HandleType::const_size_type; + using nnz_lno_type = typename HandleType::nnz_lno_t; + using MyExecSpace = typename HandleType::HandleExecSpace; + using MyTempMemorySpace = typename HandleType::HandleTempMemorySpace; + using row_lno_view_device_type = typename lno_row_view_t_::device_type; + using const_lno_row_view_type = typename lno_row_view_t_::const_type; + using const_lno_nnz_view_type = typename lno_nnz_view_t_::const_type; + using non_const_lno_nnz_view_type = typename lno_nnz_view_t_::non_const_type; + using const_clno_row_view_type = typename clno_row_view_t_::const_type; + using const_clno_nnz_view_type = typename clno_nnz_view_t_::const_type; + using non_const_clno_nnz_view_type = typename clno_nnz_view_t_::non_const_type; + using size_type_temp_work_view_type = typename HandleType::size_type_temp_work_view_t; + using scalar_temp_work_view_type = typename HandleType::scalar_temp_work_view_t; + using nnz_lno_persistent_work_view_type = typename HandleType::nnz_lno_persistent_work_view_t; + using nnz_lno_temp_work_view_type = typename HandleType::nnz_lno_temp_work_view_t; + using single_dim_index_view_type = typename Kokkos::View; + using my_exec_space = Kokkos::RangePolicy; protected: - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) - const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap - const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - HandleType* handle; // the handle. + nnz_lno_type nr; // num_rows (# verts) + nnz_lno_type nc; // num cols + size_type ne; // # edges + const_lno_row_view_type xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_type adj; // entries, transpose of entries (size = # edges) + const_clno_row_view_type t_xadj; // rowmap, transpose of rowmap + const_clno_nnz_view_type t_adj; // entries, transpose of entries + nnz_lno_type nv; // num vertices + HandleType* handle; // the handle. bool verbose; @@ -131,14 +123,14 @@ class GraphColorDistance2MatrixSquared * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorDistance2MatrixSquared(nnz_lno_t nr_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType* handle) + GraphColorDistance2MatrixSquared(nnz_lno_type nr_, + nnz_lno_type nc_, + size_type ne_, + const_lno_row_view_type row_map, + const_lno_nnz_view_type entries, + const_clno_row_view_type t_row_map, + const_clno_nnz_view_type t_entries, + HandleType* handle) : nr(nr_) , nc(nc_) , ne(ne_) @@ -177,7 +169,7 @@ class GraphColorDistance2MatrixSquared std::string algName = "SPGEMM_KK_MEMSPEED"; handle->create_spgemm_handle(KokkosSparse::StringToSPGEMMAlgorithm(algName)); - size_type_temp_work_view_t cRowptrs("cRowptrs", nr + 1); + size_type_temp_work_view_type cRowptrs("cRowptrs", nr + 1); // Call symbolic multiplication of graph with itself (no transposes, and A and B are the same) KokkosSparse::Experimental::spgemm_symbolic(handle, nr, nc, nr, xadj, adj, false, t_xadj, t_adj, false, cRowptrs); @@ -187,11 +179,11 @@ class GraphColorDistance2MatrixSquared // Must create placeholder value views for A and C (values are meaningless) // Said above that the scalar view type is the same as the colinds view type - scalar_temp_work_view_t aFakeValues("A/B placeholder values (meaningless)", adj.size()); + scalar_temp_work_view_type aFakeValues("A/B placeholder values (meaningless)", adj.size()); // Allocate C entries array, and placeholder values - nnz_lno_persistent_work_view_t cColinds("C colinds", Cnnz); - scalar_temp_work_view_t cFakeValues("C placeholder values (meaningless)", Cnnz); + nnz_lno_persistent_work_view_type cColinds("C colinds", Cnnz); + scalar_temp_work_view_type cFakeValues("C placeholder values (meaningless)", Cnnz); // Run the numeric kernel KokkosSparse::Experimental::spgemm_numeric( @@ -210,7 +202,8 @@ class GraphColorDistance2MatrixSquared // Now run distance-1 graph coloring on C, use LocalOrdinal for storing colors handle->create_graph_coloring_handle(); - KokkosGraph::Experimental::graph_color(handle, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); + KokkosGraph::Experimental::graph_color( + handle, nr, nr, /*(const_rowptrs_view)*/ cRowptrs, /*(const_colinds_view)*/ cColinds); if(this->verbose) { @@ -225,8 +218,10 @@ class GraphColorDistance2MatrixSquared // color_view_type colorsDevice = coloringHandle->get_vertex_colors(); // std::cout << "Num phases: " << handle->get_graph_coloring_handle()->get_num_phases() << std::endl; - this->handle->get_distance2_graph_coloring_handle()->set_num_phases(this->handle->get_graph_coloring_handle()->get_num_phases()); - this->handle->get_distance2_graph_coloring_handle()->set_vertex_colors(this->handle->get_graph_coloring_handle()->get_vertex_colors()); + this->handle->get_distance2_graph_coloring_handle()->set_num_phases( + this->handle->get_graph_coloring_handle()->get_num_phases()); + this->handle->get_distance2_graph_coloring_handle()->set_vertex_colors( + this->handle->get_graph_coloring_handle()->get_vertex_colors()); // clean up coloring handle handle->destroy_graph_coloring_handle(); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 742fb1f75f..58954e8155 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -59,7 +59,7 @@ #include #include "KokkosGraph_GraphColor.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this +#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this #include "KokkosGraph_GraphColorDistance2Handle.hpp" #include "KokkosKernels_Handle.hpp" @@ -68,7 +68,7 @@ namespace KokkosGraph { namespace Impl { -#define VB_D2_COLORING_FORBIDDEN_SIZE 64 +#define VB_D2_COLORING_FORBIDDEN_SIZE 64 #define VBBIT_D2_COLORING_FORBIDDEN_SIZE 64 @@ -79,80 +79,71 @@ namespace Impl { * This class supports direct methods for distance-2 graph coloring. * */ -template +template class GraphColorDistance2 { - // static_assert( std::is_same< HandleType, KokkosGraph::GraphColorDistance2Handle>::value, "Incorrect HandleType for this class."); + // static_assert( std::is_same< HandleType, KokkosGraph::GraphColorDistance2Handle>::value, "Incorrect HandleType for this + // class."); public: - typedef lno_row_view_t_ in_lno_row_view_t; - typedef lno_nnz_view_t_ in_lno_nnz_view_t; + using in_lno_row_view_type = lno_row_view_t_; + using in_lno_nnz_view_type = lno_nnz_view_t_; + using color_view_type = typename HandleType::color_view_type; + using color_type = typename HandleType::color_type; + using size_type = typename HandleType::size_type; + using nnz_lno_type = typename HandleType::nnz_lno_type; + using row_lno_host_view_type = typename in_lno_row_view_type::HostMirror; + using nnz_lno_host_view_type = typename in_lno_nnz_view_type::HostMirror; + using color_host_view_type = typename HandleType::color_host_view_type; + using MyExecSpace = typename HandleType::HandleExecSpace; + using MyTempMemorySpace = typename HandleType::HandleTempMemorySpace; + using const_size_type = typename HandleType::const_size_type; + using row_lno_view_device_type = typename lno_row_view_t_::device_type; + using const_lno_row_view_type = typename lno_row_view_t_::const_type; + using const_lno_nnz_view_t = typename lno_nnz_view_t_::const_type; + using non_const_lno_nnz_view_type = typename lno_nnz_view_t_::non_const_type; + using const_clno_row_view_t = typename clno_row_view_t_::const_type; + using const_clno_nnz_view_t = typename clno_nnz_view_t_::const_type; + using non_const_clno_nnz_view_t = typename clno_nnz_view_t_::non_const_type; + using nnz_lno_temp_work_view_t = typename HandleType::nnz_lno_temp_work_view_type; + using single_dim_index_view_type = typename Kokkos::View; + using my_exec_space = Kokkos::RangePolicy; + using team_policy_type = Kokkos::TeamPolicy; + using team_member_type = typename team_policy_type::member_type; + using non_const_1d_bool_view_t = Kokkos::View; + using non_const_1d_size_type_view_type = typename HandleType::non_const_1d_size_type_view_type; + using bit_64_forbidden_type = long long int; + + // For HashmapAccumulator (EXPERIMENTAL) + using pool_memory_space_t = typename KokkosKernels::Impl::UniformMemoryPool; - typedef typename HandleType::color_view_t color_view_type; - typedef typename HandleType::color_t color_t; - - typedef typename HandleType::size_type size_type; - typedef typename HandleType::nnz_lno_t nnz_lno_t; - - typedef typename in_lno_row_view_t::HostMirror row_lno_host_view_t; // host view type - typedef typename in_lno_nnz_view_t::HostMirror nnz_lno_host_view_t; // host view type - typedef typename HandleType::color_host_view_t color_host_view_t; // host view type - - typedef typename HandleType::HandleExecSpace MyExecSpace; - typedef typename HandleType::HandleTempMemorySpace MyTempMemorySpace; - typedef typename HandleType::const_size_type const_size_type; - - typedef typename lno_row_view_t_::device_type row_lno_view_device_t; - typedef typename lno_row_view_t_::const_type const_lno_row_view_t; - typedef typename lno_nnz_view_t_::const_type const_lno_nnz_view_t; - typedef typename lno_nnz_view_t_::non_const_type non_const_lno_nnz_view_t; - - typedef typename clno_row_view_t_::const_type const_clno_row_view_t; - typedef typename clno_nnz_view_t_::const_type const_clno_nnz_view_t; - typedef typename clno_nnz_view_t_::non_const_type non_const_clno_nnz_view_t; - - typedef typename HandleType::nnz_lno_temp_work_view_t nnz_lno_temp_work_view_t; - typedef typename Kokkos::View single_dim_index_view_type; - - typedef Kokkos::RangePolicy my_exec_space; - - typedef Kokkos::TeamPolicy team_policy_t; - typedef typename team_policy_t::member_type team_member_t; - - typedef Kokkos::View non_const_1d_bool_view_t; - - typedef typename HandleType::non_const_1d_size_type_view_t non_const_1d_size_type_view_t; - - // For HashmapAccumulator - typedef typename KokkosKernels::Impl::UniformMemoryPool pool_memory_space_t; // EXPERIMENTAL - - typedef long long int bit_64_forbidden_t; protected: + nnz_lno_type nv; // num vertices + nnz_lno_type nr; // num_rows (# verts) + nnz_lno_type nc; // num cols + size_type ne; // # edges + const_lno_row_view_type xadj; // rowmap, transpose of rowmap + const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) + const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap + const_clno_nnz_view_t t_adj; // entries, transpose of entries - nnz_lno_t nv; // num vertices - nnz_lno_t nr; // num_rows (# verts) - nnz_lno_t nc; // num cols - size_type ne; // # edges - const_lno_row_view_t xadj; // rowmap, transpose of rowmap - const_lno_nnz_view_t adj; // entries, transpose of entries (size = # edges) - const_clno_row_view_t t_xadj; // rowmap, transpose of rowmap - const_clno_nnz_view_t t_adj; // entries, transpose of entries - - HandleType * gc_handle; // pointer to the graph coloring handle + HandleType* gc_handle; // pointer to the graph coloring handle private: - - int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs - int _max_num_iterations; - char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). - bool _ticToc; // if true print info in each step - bool _verbose; // if true, print verbose information + int _chunkSize; // the size of the minimum work unit assigned to threads. Changes the convergence on GPUs + int _max_num_iterations; + char _use_color_set; // The VB Algorithm Type: 0: VB, 1: VBCS, 2: VBBIT (1, 2 not implemented). + bool _ticToc; // if true print info in each step + bool _verbose; // if true, print verbose information public: - /** * \brief GraphColorDistance2 constructor. * \param nv_: number of vertices in the graph @@ -162,14 +153,14 @@ class GraphColorDistance2 * \param handle: GraphColoringHandle object that holds the specification about the graph coloring, * including parameters. */ - GraphColorDistance2(nnz_lno_t nv_, - nnz_lno_t nc_, - size_type ne_, - const_lno_row_view_t row_map, - const_lno_nnz_view_t entries, - const_clno_row_view_t t_row_map, - const_clno_nnz_view_t t_entries, - HandleType* handle) + GraphColorDistance2(nnz_lno_type nv_, + nnz_lno_type nc_, + size_type ne_, + const_lno_row_view_type row_map, + const_lno_nnz_view_t entries, + const_clno_row_view_t t_row_map, + const_clno_nnz_view_t t_entries, + HandleType* handle) : nv(nv_) , nr(nv_) , nc(nc_) @@ -243,12 +234,12 @@ class GraphColorDistance2 */ } - #if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation +#if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation // Compute Distance-2 Degree of the vertices. // -- Keeping this around in case we need to use it later on as an example. size_t degree_d2_max=0; size_t degree_d2_sum=0; - non_const_1d_size_type_view_t degree_d2 = non_const_1d_size_type_view_t("degree d2", this->nv); + non_const_1d_size_type_view_type degree_d2 = non_const_1d_size_type_view_type("degree d2", this->nv); this->compute_distance2_degree(degree_d2, degree_d2_max, degree_d2_sum); if(true || _ticToc ) { @@ -256,13 +247,15 @@ class GraphColorDistance2 std::cout << ">>> Max D2 Degree: " << degree_d2_max << std::endl; std::cout << ">>> D2 Degree Sum: " << degree_d2_sum<< std::endl; } - #endif +#endif // conflictlist - store conflicts that can happen when we're coloring in parallel. - nnz_lno_temp_work_view_t current_vertexList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); + nnz_lno_temp_work_view_t current_vertexList = + nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); // init conflictlist sequentially. - Kokkos::parallel_for("InitList", my_exec_space(0, this->nv), functorInitList(current_vertexList)); + Kokkos::parallel_for( + "InitList", my_exec_space(0, this->nv), functorInitList(current_vertexList)); // Next iteratons's conflictList nnz_lno_temp_work_view_t next_iteration_recolorList; @@ -271,15 +264,15 @@ class GraphColorDistance2 single_dim_index_view_type next_iteration_recolorListLength; // Vertices to recolor. Will swap with vertexList - next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); + next_iteration_recolorList = nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("recolorList"), this->nv); next_iteration_recolorListLength = single_dim_index_view_type("recolorListLength"); - nnz_lno_t numUncolored = this->nv; - nnz_lno_t numUncoloredPreviousIter = this->nv + 1; - nnz_lno_t current_vertexListLength = this->nv; + nnz_lno_type numUncolored = this->nv; + nnz_lno_type numUncoloredPreviousIter = this->nv + 1; + nnz_lno_type current_vertexListLength = this->nv; - double time; - double total_time = 0.0; + double time; + double total_time = 0.0; Kokkos::Impl::Timer timer; int iter = 0; @@ -307,14 +300,16 @@ class GraphColorDistance2 Kokkos::deep_copy(t_adj_copy, this->t_adj); // Debugging - //prettyPrint1DView(t_adj_copy, "t_adj_copy", 100); - //prettyPrint1DView(t_adj, "t_adj", 100); + // prettyPrint1DView(t_adj_copy, "t_adj_copy", 100); + // prettyPrint1DView(t_adj, "t_adj", 100); - this->colorGreedyEF(this->xadj, adj_copy, this->t_xadj, t_adj_copy, colors_out, current_vertexList, current_vertexListLength); + this->colorGreedyEF( + this->xadj, adj_copy, this->t_xadj, t_adj_copy, colors_out, current_vertexList, current_vertexListLength); } else { - this->colorGreedy(this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + this->colorGreedy( + this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } MyExecSpace::fence(); @@ -378,7 +373,8 @@ class GraphColorDistance2 } // Bail out if we didn't make any progress since we're probably stuck and it's better to just clean up in serial. - if(numUncolored == numUncoloredPreviousIter) break; + if(numUncolored == numUncoloredPreviousIter) + break; } // end for iterations && numUncolored > 0... @@ -387,7 +383,14 @@ class GraphColorDistance2 // ------------------------------------------ if(numUncolored > 0) { - this->resolveConflictsSerial(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); + this->resolveConflictsSerial(this->nv, + this->xadj, + this->adj, + this->t_xadj, + this->t_adj, + colors_out, + current_vertexList, + current_vertexListLength); } MyExecSpace::fence(); @@ -411,30 +414,29 @@ class GraphColorDistance2 /** * Validate Distance 2 Graph Coloring * - * @param[in] validation_flags Is an array of 3 booleans to capture if the graph coloring is invalid, and if so what is invalid. - * validation_flags[0] : True IF the distance-2 coloring is invalid. - * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. - * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices - * at distance=2 from each other has the same color. - * validation_flags[3] : True IF a vertex has a color that is greater than number of vertices in the graph. - * This may not be an INVALID coloring, but can indicate poor quality in coloring. + * @param[in] validation_flags Is an array of 3 booleans to capture if the graph coloring is invalid, and if so what is + * invalid. validation_flags[0] : True IF the distance-2 coloring is invalid. validation_flags[1] : True IF the coloring is + * bad because vertices are left uncolored. validation_flags[2] : True IF the coloring is bad because at least one pair of + * vertices at distance=2 from each other has the same color. validation_flags[3] : True IF a vertex has a color that is + * greater than number of vertices in the graph. This may not be an INVALID coloring, but can indicate poor quality in + * coloring. * * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. */ - bool verify_coloring(const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - bool validation_flags[]) + bool verify_coloring(const_lno_row_view_type xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + bool validation_flags[]) { bool output = true; - validation_flags[0] = false; // True if an invalid coloring. - validation_flags[1] = false; // True if uncolored vertices exist. - validation_flags[2] = false; // True if an invalid color exists. + validation_flags[ 0 ] = false; // True if an invalid coloring. + validation_flags[ 1 ] = false; // True if uncolored vertices exist. + validation_flags[ 2 ] = false; // True if an invalid color exists. - nnz_lno_t chunkSize_ = this->_chunkSize; + nnz_lno_type chunkSize_ = this->_chunkSize; if(nv < 100 * chunkSize_) { chunkSize_ = 1; @@ -458,12 +460,12 @@ class GraphColorDistance2 // Deep copy flags back to host memory Kokkos::deep_copy(h_flags, d_flags); - validation_flags[0] = h_flags[0]; - validation_flags[1] = h_flags[1]; - validation_flags[2] = h_flags[2]; - validation_flags[3] = h_flags[3]; + validation_flags[ 0 ] = h_flags[ 0 ]; + validation_flags[ 1 ] = h_flags[ 1 ]; + validation_flags[ 2 ] = h_flags[ 2 ]; + validation_flags[ 3 ] = h_flags[ 3 ]; - output = !h_flags[0]; + output = !h_flags[ 0 ]; return output; } // verify_coloring (end) @@ -478,10 +480,10 @@ class GraphColorDistance2 * * @return None */ - void compute_color_histogram(nnz_lno_temp_work_view_t & histogram) + void compute_color_histogram(nnz_lno_temp_work_view_t& histogram) { - KokkosKernels::Impl::kk_get_histogram - (this->nv, this->gc_handle->get_vertex_colors(), histogram); + KokkosKernels::Impl::kk_get_histogram( + this->nv, this->gc_handle->get_vertex_colors(), histogram); MyExecSpace::fence(); } @@ -493,7 +495,7 @@ class GraphColorDistance2 */ void print_color_histogram_csv() { - nnz_lno_t num_colors = this->gc_handle->get_num_colors(); + nnz_lno_type num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); @@ -502,11 +504,8 @@ class GraphColorDistance2 auto h_histogram = Kokkos::create_mirror_view(histogram); Kokkos::deep_copy(h_histogram, histogram); - size_t i=0; - for(i=1; i< h_histogram.extent(0)-1; i++) - { - std::cout << h_histogram(i) << ","; - } + size_t i = 0; + for(i = 1; i < h_histogram.extent(0) - 1; i++) { std::cout << h_histogram(i) << ","; } std::cout << h_histogram(i); } @@ -518,7 +517,7 @@ class GraphColorDistance2 */ void print_color_histogram() { - nnz_lno_t num_colors = this->gc_handle->get_num_colors(); + nnz_lno_type num_colors = this->gc_handle->get_num_colors(); nnz_lno_temp_work_view_t histogram("histogram", num_colors + 1); this->compute_color_histogram(histogram); std::cout << "Distance-2 Color Histogram: " << std::endl; @@ -537,32 +536,32 @@ class GraphColorDistance2 * @note This is EXPERIMENTAL development code. * @todo Uses HashMapAccumulator and still needs a lot of tweaking to make performant. */ - void compute_distance2_degree(non_const_1d_size_type_view_t °ree_d2, size_t °ree_d2_max) + void compute_distance2_degree(non_const_1d_size_type_view_type& degree_d2, size_t& degree_d2_max) { // Vertex group chunking - nnz_lno_t v_chunk_size = this->_chunkSize; - nnz_lno_t v_num_chunks = this->nv / v_chunk_size + 1; + nnz_lno_type v_chunk_size = this->_chunkSize; + nnz_lno_type v_num_chunks = this->nv / v_chunk_size + 1; std::cout << ">>> this->nv = " << this->nv << std::endl; std::cout << ">>> v_chunk_size = " << v_chunk_size << std::endl; std::cout << ">>> v_num_chunks = " << v_num_chunks << std::endl; // Get the maximum distance-1 degree - nnz_lno_t max_d1_degree = this->compute_max_distance1_degree(); + nnz_lno_type max_d1_degree = this->compute_max_distance1_degree(); // Round up hash_size to next power of two - nnz_lno_t hash_size = 1; - while(hash_size < max_d1_degree*max_d1_degree) { hash_size *= 2; } + nnz_lno_type hash_size = 1; + while(hash_size < max_d1_degree * max_d1_degree) { hash_size *= 2; } // Max Nonzeros in D2 context can be max_degree(G)^2 - nnz_lno_t max_nonzeros = max_d1_degree * max_d1_degree; + nnz_lno_type max_nonzeros = max_d1_degree * max_d1_degree; // Determine how much we'd need for UniformMemoryPool - nnz_lno_t mem_chunk_size = hash_size; // For hash indices - mem_chunk_size += hash_size; // For hash begins - mem_chunk_size += max_nonzeros; // For hash nexts - mem_chunk_size += max_nonzeros; // For hash keys - // nnz_lno_t mem_chunk_size += max_nonzeros; // For hash_values + nnz_lno_type mem_chunk_size = hash_size; // For hash indices + mem_chunk_size += hash_size; // For hash begins + mem_chunk_size += max_nonzeros; // For hash nexts + mem_chunk_size += max_nonzeros; // For hash keys + // nnz_lno_type mem_chunk_size += max_nonzeros; // For hash_values /* std::cout << "num_verts = " << this->nv << std::endl; @@ -575,45 +574,44 @@ class GraphColorDistance2 // HashmapAccumulator requires a memory Pool KokkosKernels::Impl::PoolType my_pool_type = KokkosKernels::Impl::OneThread2OneChunk; - pool_memory_space_t m_space(v_num_chunks, mem_chunk_size, -1, my_pool_type); + pool_memory_space_t m_space(v_num_chunks, mem_chunk_size, -1, my_pool_type); /* std::cout << std::endl << "Memory Pool:" << std::endl; m_space.print_memory_pool(true); */ - functorCalculateD2Degree calculateD2Degree(this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, v_chunk_size, degree_d2, m_space, hash_size, max_nonzeros); + functorCalculateD2Degree calculateD2Degree( + this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, v_chunk_size, degree_d2, m_space, hash_size, max_nonzeros); Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, v_num_chunks), calculateD2Degree); // Compute maximum d2 degree size_t _degree_d2_max = 0; - Kokkos::parallel_reduce("Max D2 Degree", - this->nv, - KOKKOS_LAMBDA(const size_t &i, size_t & lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, - Kokkos::Max(_degree_d2_max)); + Kokkos::parallel_reduce( + "Max D2 Degree", + this->nv, + KOKKOS_LAMBDA(const size_t& i, size_t & lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, + Kokkos::Max(_degree_d2_max)); degree_d2_max = _degree_d2_max; } private: - - - // ----------------------------------------------------------------- // // GraphColorDistance2::colorGreedy() // // ----------------------------------------------------------------- - void colorGreedy(const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, + void colorGreedy(const_lno_row_view_type xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, nnz_lno_temp_work_view_t current_vertexList_, - nnz_lno_t current_vertexListLength_) + nnz_lno_type current_vertexListLength_) { - nnz_lno_t chunkSize_ = this->_chunkSize; + nnz_lno_type chunkSize_ = this->_chunkSize; if(current_vertexListLength_ < 100 * chunkSize_) { @@ -631,7 +629,8 @@ class GraphColorDistance2 case COLORING_D2: case COLORING_D2_VB: { - functorGreedyColorVB gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + functorGreedyColorVB gc( + this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; @@ -643,7 +642,8 @@ class GraphColorDistance2 // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VB_BIT: { - functorGreedyColorVB_BIT gc(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); + functorGreedyColorVB_BIT gc( + this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); } break; @@ -661,13 +661,13 @@ class GraphColorDistance2 // GraphColorDistance2::colorGreedyEF() // // ----------------------------------------------------------------- - void colorGreedyEF(const_lno_row_view_t xadj_, - nnz_lno_temp_work_view_t adj_copy_, - const_clno_row_view_t t_xadj_, + void colorGreedyEF(const_lno_row_view_type xadj_, + nnz_lno_temp_work_view_t adj_copy_, + const_clno_row_view_t t_xadj_, non_const_clno_nnz_view_t t_adj_copy_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - nnz_lno_t current_vertexListLength_) + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + nnz_lno_type current_vertexListLength_) { // Pick the right coloring algorithm to use based on which algorithm we're using switch(this->gc_handle->get_coloring_algo_type()) @@ -679,8 +679,14 @@ class GraphColorDistance2 // 4. [S] loop over vertex neighbors of neighbors case COLORING_D2_VB_BIT_EF: { - functorGreedyColorVB_BIT_EF gc( - this->nv, xadj_, adj_copy_, t_xadj_, t_adj_copy_, vertex_colors_, current_vertexList_, current_vertexListLength_); + functorGreedyColorVB_BIT_EF gc(this->nv, + xadj_, + adj_copy_, + t_xadj_, + t_adj_copy_, + vertex_colors_, + current_vertexList_, + current_vertexListLength_); Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); // prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); } @@ -699,23 +705,31 @@ class GraphColorDistance2 // // ----------------------------------------------------------------- template - nnz_lno_t findConflicts(bool &swap_work_arrays, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - nnz_lno_t current_vertexListLength_, - nnz_lno_temp_work_view_t next_iteration_recolorList_, - single_dim_index_view_type next_iteration_recolorListLength_) + nnz_lno_type findConflicts(bool& swap_work_arrays, + const_lno_row_view_type xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + nnz_lno_type current_vertexListLength_, + nnz_lno_temp_work_view_t next_iteration_recolorList_, + single_dim_index_view_type next_iteration_recolorListLength_) { - swap_work_arrays = true; - nnz_lno_t output_numUncolored = 0; + swap_work_arrays = true; + nnz_lno_type output_numUncolored = 0; if(0 == this->_use_color_set) { - functorFindConflicts_Atomic conf(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, next_iteration_recolorList_, next_iteration_recolorListLength_); + functorFindConflicts_Atomic conf(this->nv, + xadj_, + adj_, + t_xadj_, + t_adj_, + vertex_colors_, + current_vertexList_, + next_iteration_recolorList_, + next_iteration_recolorListLength_); Kokkos::parallel_reduce("FindConflicts", my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); } @@ -730,18 +744,18 @@ class GraphColorDistance2 // // ----------------------------------------------------------------- template - void resolveConflictsSerial(nnz_lno_t _nv, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type vertex_colors_, - nnz_lno_temp_work_view_t current_vertexList_, - size_type current_vertexListLength_) + void resolveConflictsSerial(nnz_lno_type _nv, + const_lno_row_view_type xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type vertex_colors_, + nnz_lno_temp_work_view_t current_vertexList_, + size_type current_vertexListLength_) { - color_t *forbidden = new color_t[_nv]; - nnz_lno_t vid = 0; - nnz_lno_t end = _nv; + color_type* forbidden = new color_type[ _nv ]; + nnz_lno_type vid = 0; + nnz_lno_type end = _nv; typename nnz_lno_temp_work_view_t::HostMirror h_recolor_list; @@ -765,7 +779,7 @@ class GraphColorDistance2 Kokkos::deep_copy(h_t_idx, t_xadj_); Kokkos::deep_copy(h_t_adj, t_adj_); - for(nnz_lno_t k = 0; k < end; k++) + for(nnz_lno_type k = 0; k < end; k++) { vid = h_recolor_list(k); @@ -780,19 +794,19 @@ class GraphColorDistance2 // loop over neighbors of vid_d1 (distance-2 from vid) for(size_type vid_d2_adj = h_t_idx(vid_d1); vid_d2_adj < h_t_idx(vid_d1 + 1); vid_d2_adj++) { - nnz_lno_t vid_d2 = h_t_adj(vid_d2_adj); + nnz_lno_type vid_d2 = h_t_adj(vid_d2_adj); // skip over loops vid -- x -- vid if(vid_d2 == vid) continue; - forbidden[h_colors(vid_d2)] = vid; + forbidden[ h_colors(vid_d2) ] = vid; } } // color vertex vid with smallest available color int c = 1; - while(forbidden[c] == vid) c++; + while(forbidden[ c ] == vid) c++; h_colors(vid) = c; } @@ -808,24 +822,21 @@ class GraphColorDistance2 public: - - /** * Compute the maximum distance-1 degree. * * @return Maximum distance1 degree in the graph */ - nnz_lno_t compute_max_distance1_degree() const + nnz_lno_type compute_max_distance1_degree() const { - nnz_lno_t max_degree = 0; + nnz_lno_type max_degree = 0; Kokkos::parallel_reduce("Max D1 Degree", this->nv, - KOKKOS_LAMBDA(const nnz_lno_t& vid, nnz_lno_t& lmax) - { - const nnz_lno_t degree = this->xadj(vid+1) - this->xadj(vid); - lmax = degree > lmax ? degree : lmax; + KOKKOS_LAMBDA(const nnz_lno_type& vid, nnz_lno_type & lmax) { + const nnz_lno_type degree = this->xadj(vid + 1) - this->xadj(vid); + lmax = degree > lmax ? degree : lmax; }, - Kokkos::Max(max_degree)); + Kokkos::Max(max_degree)); return max_degree; } @@ -833,7 +844,7 @@ class GraphColorDistance2 // pretty-print a 1D View with label template - void prettyPrint1DView(kokkos_view_t &view, const char *label, const size_t max_entries = 500) const + void prettyPrint1DView(kokkos_view_t& view, const char* label, const size_t max_entries = 500) const { int max_per_line = 20; int line_count = 1; @@ -874,7 +885,7 @@ class GraphColorDistance2 functorInitList(view_type vertexList) : _vertexList(vertexList) {} KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t i) const + void operator()(const nnz_lno_type i) const { // Natural order _vertexList(i) = i; @@ -889,25 +900,32 @@ class GraphColorDistance2 */ struct functorGreedyColorVB { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - nnz_lno_t _chunkSize; // - - functorGreedyColorVB(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, + nnz_lno_type nv; // num vertices + const_lno_row_view_type _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_type _vertexListLength; // + nnz_lno_type _chunkSize; // + + functorGreedyColorVB(nnz_lno_type nv_, + const_lno_row_view_type xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) + nnz_lno_type vertexListLength) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _vertexList(vertexList) + , _vertexListLength(vertexListLength) { } @@ -921,7 +939,7 @@ class GraphColorDistance2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid) const + void operator()(const nnz_lno_type vid) const { // If vertex is not already colored... if(_colors(vid) <= 0) @@ -933,45 +951,45 @@ class GraphColorDistance2 // Use forbidden array to find available color. // - should be small enough to fit into fast memory (use Kokkos memoryspace?) - bool forbidden[VB_D2_COLORING_FORBIDDEN_SIZE]; // Forbidden Colors + bool forbidden[ VB_D2_COLORING_FORBIDDEN_SIZE ]; // Forbidden Colors // Do multiple passes if the forbidden array is too small. // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. // This could be as big as all the vertices in the graph if diameter(G)=2... // * TODO: Determine if we can cap this at something lower than nv. - for(color_t offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) + for(color_type offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) { // initialize - for(int i = 0; i < VB_D2_COLORING_FORBIDDEN_SIZE; i++) { forbidden[i] = false; } + for(int i = 0; i < VB_D2_COLORING_FORBIDDEN_SIZE; i++) { forbidden[ i ] = false; } // Colors start at 1. 0 is special in that it means a vertex is uncolored. // For the range 0..63 we mark forbidden[0] as true to take color 0 out of // consideration. if(0 == offset) { - forbidden[0] = true; + forbidden[ 0 ] = true; } // Check neighbors, fill forbidden array. for(size_type vid_adj = vid_adj_begin; vid_adj < vid_adj_end; vid_adj++) { - const nnz_lno_t vid_d1 = _adj(vid_adj); - const size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const nnz_lno_type vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d1_adj); // Skip distance-2-self-loops if(vid_d2 != vid && vid_d2 < nv) { - const color_t c = _colors(vid_d2); + const color_type c = _colors(vid_d2); if((c >= offset) && (c - offset < VB_D2_COLORING_FORBIDDEN_SIZE)) { - forbidden[c - offset] = true; + forbidden[ c - offset ] = true; } } } // for vid_d1_adj... @@ -980,7 +998,7 @@ class GraphColorDistance2 // color vertex i with smallest available color (firstFit) for(int c = 0; c < VB_D2_COLORING_FORBIDDEN_SIZE; c++) { - if(!forbidden[c]) + if(!forbidden[ c ]) { _colors(vid) = offset + c; foundColor = true; @@ -1000,24 +1018,31 @@ class GraphColorDistance2 */ struct functorGreedyColorVB_BIT { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - - functorGreedyColorVB_BIT(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, + nnz_lno_type nv; // num vertices + const_lno_row_view_type _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_type _vertexListLength; // + + functorGreedyColorVB_BIT(nnz_lno_type nv_, + const_lno_row_view_type xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) + nnz_lno_type vertexListLength) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _vertexList(vertexList) + , _vertexListLength(vertexListLength) { } @@ -1031,7 +1056,7 @@ class GraphColorDistance2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid) const + void operator()(const nnz_lno_type vid) const { // If vertex is not colored yet... if(_colors(vid) == 0) @@ -1040,11 +1065,12 @@ class GraphColorDistance2 const size_type vid_adj_end = _idx(vid + 1); bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) + for(color_type offset = 0; !foundColor && offset <= (nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); + offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { // Forbidden colors // - single long int for forbidden colors - bit_64_forbidden_t forbidden = 0; + bit_64_forbidden_type forbidden = 0; // If all available colors for this range are unavailable we can break out of the nested loops bool break_out = false; @@ -1052,20 +1078,20 @@ class GraphColorDistance2 // Loop over distance-1 neighbors of vid for(size_type vid_adj = vid_adj_begin; !break_out && vid_adj < vid_adj_end; ++vid_adj) { - const nnz_lno_t vid_d1 = _adj(vid_adj); - const size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const nnz_lno_type vid_d1 = _adj(vid_adj); + const size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); // Loop over distance-2 neighbors of vid for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d1_adj); // Ignore Distance-2 Self Loops if(vid_d2 != vid && vid_d2 < nv) { - const color_t color = _colors(vid_d2); - const color_t color_offset = color - offset; + const color_type color = _colors(vid_d2); + const color_type color_offset = color - offset; // if color is within the current range, or if its color is in a previously traversed // range @@ -1075,7 +1101,7 @@ class GraphColorDistance2 if(color > offset) { // convert color to bit representation - bit_64_forbidden_t ban_color_bit = 1; + bit_64_forbidden_type ban_color_bit = 1; ban_color_bit = ban_color_bit << (color_offset - 1); @@ -1098,10 +1124,10 @@ class GraphColorDistance2 // check if an available color exists. if(forbidden) { - color_t val = 1; + color_type val = 1; // if there is an available color, choose the first color, using 2s complement. - bit_64_forbidden_t new_color = forbidden & (-forbidden); + bit_64_forbidden_type new_color = forbidden & (-forbidden); // convert it back to decimal color. while((new_color & 1) == 0) @@ -1120,30 +1146,37 @@ class GraphColorDistance2 - /** + /** * Functor for VB_BIT_EF algorithm coloring without edge filtering. * Single level parallelism */ struct functorGreedyColorVB_BIT_EF { - nnz_lno_t _nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - nnz_lno_temp_work_view_t _adj; // vertex adjacency list (mutable) - const_clno_row_view_t _t_idx; // transpose vertex degree list - non_const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list (mutable) - color_view_type _colors; // vertex colors - nnz_lno_temp_work_view_t _vertexList; // - nnz_lno_t _vertexListLength; // - - functorGreedyColorVB_BIT_EF(nnz_lno_t nv, - const_lno_row_view_t xadj, - nnz_lno_temp_work_view_t adj, - const_clno_row_view_t t_xadj, + nnz_lno_type _nv; // num vertices + const_lno_row_view_type _idx; // vertex degree list + nnz_lno_temp_work_view_t _adj; // vertex adjacency list (mutable) + const_clno_row_view_t _t_idx; // transpose vertex degree list + non_const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list (mutable) + color_view_type _colors; // vertex colors + nnz_lno_temp_work_view_t _vertexList; // + nnz_lno_type _vertexListLength; // + + functorGreedyColorVB_BIT_EF(nnz_lno_type nv, + const_lno_row_view_type xadj, + nnz_lno_temp_work_view_t adj, + const_clno_row_view_t t_xadj, non_const_clno_nnz_view_t t_adj, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_t vertexListLength) - : _nv(nv), _idx(xadj), _adj(adj), _t_idx(t_xadj), _t_adj(t_adj), _colors(colors), _vertexList(vertexList), _vertexListLength(vertexListLength) + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_type vertexListLength) + : _nv(nv) + , _idx(xadj) + , _adj(adj) + , _t_idx(t_xadj) + , _t_adj(t_adj) + , _colors(colors) + , _vertexList(vertexList) + , _vertexListLength(vertexListLength) { } @@ -1157,7 +1190,7 @@ class GraphColorDistance2 // param: ii = vertex id // KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid) const + void operator()(const nnz_lno_type vid) const { // If vertex is not colored yet.. if(_colors(vid) == 0) @@ -1166,11 +1199,12 @@ class GraphColorDistance2 size_type vid_adj_end = _idx(vid + 1); bool foundColor = false; - for(color_t offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) + for(color_type offset = 0; !foundColor && offset <= (_nv + VBBIT_D2_COLORING_FORBIDDEN_SIZE); + offset += VBBIT_D2_COLORING_FORBIDDEN_SIZE) { // Forbidden colors // - single long int for forbidden colors - bit_64_forbidden_t forbidden = 0; + bit_64_forbidden_type forbidden = 0; // If all available colors for this range are unavailable we can break out of the nested loops bool offset_colors_full = false; @@ -1178,26 +1212,28 @@ class GraphColorDistance2 // Loop over distance-1 neighbors of vid for(size_type vid_adj = vid_adj_begin; !offset_colors_full && vid_adj < vid_adj_end; ++vid_adj) { - const nnz_lno_t vid_d1 = _adj(vid_adj); + const nnz_lno_type vid_d1 = _adj(vid_adj); - size_type vid_d1_adj_begin = _t_idx(vid_d1); - const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); - const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; - size_type num_vid_d2_colored_in_range = 0; + size_type vid_d1_adj_begin = _t_idx(vid_d1); + const size_type vid_d1_adj_end = _t_idx(vid_d1 + 1); + const size_type degree_vid_d1 = vid_d1_adj_end - vid_d1_adj_begin; + size_type num_vid_d2_colored_in_range = 0; // Store the maximum color value found in the vertices adjacent to vid_d1 - color_t max_color_adj_to_d1 = 0; + color_type max_color_adj_to_d1 = 0; // Loop over distance-2 neighbors of vid - for(size_type vid_d1_adj = vid_d1_adj_begin; !offset_colors_full && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) + for(size_type vid_d1_adj = vid_d1_adj_begin; !offset_colors_full && vid_d1_adj < vid_d1_adj_end; + ++vid_d1_adj) { - const nnz_lno_t vid_d2 = _t_adj(vid_d1_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d1_adj); // Ignore Distance-2 Self Loops if(vid_d2 != vid && vid_d2 < _nv) { - color_t color = _colors(vid_d2); - color_t color_offset = color - offset; // color_offset < 0 means color is from a previous offset. + color_type color = _colors(vid_d2); + color_type color_offset = + color - offset; // color_offset < 0 means color is from a previous offset. // Update maximum color adjacent to vid_d1 found so far. max_color_adj_to_d1 = color > max_color_adj_to_d1 ? color : max_color_adj_to_d1; @@ -1212,7 +1248,7 @@ class GraphColorDistance2 if(color > offset) { // convert color to bit representation - bit_64_forbidden_t ban_color_bit = 1; + bit_64_forbidden_type ban_color_bit = 1; ban_color_bit = ban_color_bit << (color_offset - 1); @@ -1258,8 +1294,8 @@ class GraphColorDistance2 if(forbidden) { // if there is an available color, choose the first color, using 2s complement. - bit_64_forbidden_t new_color = forbidden & (-forbidden); - color_t val = 1; + bit_64_forbidden_type new_color = forbidden & (-forbidden); + color_type val = 1; // convert it back to decimal color. while((new_color & 1) == 0) @@ -1281,50 +1317,58 @@ class GraphColorDistance2 template struct functorFindConflicts_Atomic { - nnz_lno_t nv; // num verts - const_lno_row_view_t _idx; - adj_view_t _adj; - const_clno_row_view_t _t_idx; - const_clno_nnz_view_t _t_adj; - color_view_type _colors; - nnz_lno_temp_work_view_t _vertexList; - nnz_lno_temp_work_view_t _recolorList; + nnz_lno_type nv; // num verts + const_lno_row_view_type _idx; + adj_view_t _adj; + const_clno_row_view_t _t_idx; + const_clno_nnz_view_t _t_adj; + color_view_type _colors; + nnz_lno_temp_work_view_t _vertexList; + nnz_lno_temp_work_view_t _recolorList; single_dim_index_view_type _recolorListLength; - functorFindConflicts_Atomic(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - adj_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, - nnz_lno_temp_work_view_t vertexList, - nnz_lno_temp_work_view_t recolorList, + functorFindConflicts_Atomic(nnz_lno_type nv_, + const_lno_row_view_type xadj_, + adj_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, + nnz_lno_temp_work_view_t vertexList, + nnz_lno_temp_work_view_t recolorList, single_dim_index_view_type recolorListLength) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _vertexList(vertexList), _recolorList(recolorList), - _recolorListLength(recolorListLength) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _vertexList(vertexList) + , _recolorList(recolorList) + , _recolorListLength(recolorListLength) { } KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t vid_, nnz_lno_t &numConflicts) const + void operator()(const nnz_lno_type vid_, nnz_lno_type& numConflicts) const { - typedef typename std::remove_reference::type atomic_incr_type; - const nnz_lno_t vid = _vertexList(vid_); - const color_t my_color = _colors(vid); + using atomic_incr_type = typename std::remove_reference::type; - size_type vid_d1_adj = _idx(vid); + const nnz_lno_type vid = _vertexList(vid_); + const color_type my_color = _colors(vid); + + size_type vid_d1_adj = _idx(vid); const size_type vid_d1_adj_end = _idx(vid + 1); bool break_out = false; for(; !break_out && vid_d1_adj < vid_d1_adj_end; vid_d1_adj++) { - nnz_lno_t vid_d1 = _adj(vid_d1_adj); + nnz_lno_type vid_d1 = _adj(vid_d1_adj); for(size_type vid_d2_adj = _t_idx(vid_d1); !break_out && vid_d2_adj < _t_idx(vid_d1 + 1); vid_d2_adj++) { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d2_adj); if(vid != vid_d2 && vid_d2 < nv) { @@ -1333,8 +1377,8 @@ class GraphColorDistance2 _colors(vid) = 0; // uncolor vertex // Atomically add vertex to recolorList - const nnz_lno_t k = Kokkos::atomic_fetch_add(&_recolorListLength(), atomic_incr_type(1)); - _recolorList(k) = vid; + const nnz_lno_type k = Kokkos::atomic_fetch_add(&_recolorListLength(), atomic_incr_type(1)); + _recolorList(k) = vid; numConflicts += 1; break_out = true; // break; // Can exit if vertex gets marked as a conflict. @@ -1353,46 +1397,53 @@ class GraphColorDistance2 */ struct functorVerifyDistance2Coloring { - nnz_lno_t nv; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - color_view_type _colors; // vertex colors - non_const_1d_bool_view_t - _flags; // [0]: valid or not? [1]=true means something is uncolored. [2]=true means something has distance-2 neighbor of same color - nnz_lno_t _chunkSize; // - - functorVerifyDistance2Coloring(nnz_lno_t nv_, - const_lno_row_view_t xadj_, - const_lno_nnz_view_t adj_, - const_clno_row_view_t t_xadj_, - const_clno_nnz_view_t t_adj_, - color_view_type colors, + nnz_lno_type nv; // num vertices + const_lno_row_view_type _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + color_view_type _colors; // vertex colors + non_const_1d_bool_view_t _flags; // [0]: valid or not? [1]=true means something is uncolored. [2]=true means + // something has distance-2 neighbor of same color + nnz_lno_type _chunkSize; // + + functorVerifyDistance2Coloring(nnz_lno_type nv_, + const_lno_row_view_type xadj_, + const_lno_nnz_view_t adj_, + const_clno_row_view_t t_xadj_, + const_clno_nnz_view_t t_adj_, + color_view_type colors, non_const_1d_bool_view_t flags, - nnz_lno_t chunkSize) - : nv(nv_), _idx(xadj_), _adj(adj_), _t_idx(t_xadj_), _t_adj(t_adj_), _colors(colors), _flags(flags), _chunkSize(chunkSize) + nnz_lno_type chunkSize) + : nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) + , _colors(colors) + , _flags(flags) + , _chunkSize(chunkSize) { } KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t chunk_id) const + void operator()(const nnz_lno_type chunk_id) const { bool has_uncolored_vertex = false; bool has_invalid_color = false; bool has_color_bigger_than_num_verts = false; // Loop over vertices in chunks - for(nnz_lno_t chunk_idx = 0; chunk_idx < _chunkSize; chunk_idx++) + for(nnz_lno_type chunk_idx = 0; chunk_idx < _chunkSize; chunk_idx++) { - bool break_out = false; - nnz_lno_t vid = chunk_id * _chunkSize + chunk_idx; + bool break_out = false; + nnz_lno_type vid = chunk_id * _chunkSize + chunk_idx; if(vid < nv) { - const color_t color_vid = _colors(vid); - const size_type vid_d1_adj_begin = _idx(vid); - const size_type vid_d1_adj_end = _idx(vid + 1); + const color_type color_vid = _colors(vid); + const size_type vid_d1_adj_begin = _idx(vid); + const size_type vid_d1_adj_end = _idx(vid + 1); if(color_vid == 0) { @@ -1407,19 +1458,19 @@ class GraphColorDistance2 // Loop over neighbors of vid (distance-1 from vid) for(size_type vid_d1_adj = vid_d1_adj_begin; !break_out && vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - const size_type vid_d2_adj_begin = _t_idx(vid_d1); - const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + const nnz_lno_type vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); // Loop over neighbors of vid_d1 (distance-2 from vid) for(size_type vid_d2_adj = vid_d2_adj_begin; !break_out && vid_d2_adj < vid_d2_adj_end; ++vid_d2_adj) { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d2_adj); // Ignore Distance-2 self loops if(vid != vid_d2) { - const color_t color_d2 = _colors(vid_d2); + const color_type color_d2 = _colors(vid_d2); // If distance-2 neighbor of vid has the same color as vid, then the coloring is invalid if(color_vid == color_d2) { @@ -1432,13 +1483,13 @@ class GraphColorDistance2 } } if(has_uncolored_vertex || has_invalid_color) - Kokkos::atomic_fetch_or(&_flags[0], has_uncolored_vertex || has_invalid_color); + Kokkos::atomic_fetch_or(&_flags[ 0 ], has_uncolored_vertex || has_invalid_color); if(has_uncolored_vertex) - Kokkos::atomic_fetch_or(&_flags[1], has_uncolored_vertex); + Kokkos::atomic_fetch_or(&_flags[ 1 ], has_uncolored_vertex); if(has_invalid_color) - Kokkos::atomic_fetch_or(&_flags[2], has_invalid_color); + Kokkos::atomic_fetch_or(&_flags[ 2 ], has_invalid_color); if(has_color_bigger_than_num_verts) - Kokkos::atomic_fetch_or(&_flags[3], has_color_bigger_than_num_verts); + Kokkos::atomic_fetch_or(&_flags[ 3 ], has_color_bigger_than_num_verts); } // operator() }; // struct functorVerifyDistance2Coloring (end) @@ -1450,93 +1501,90 @@ class GraphColorDistance2 */ struct functorCalculateD2Degree { - nnz_lno_t _num_verts; // num vertices - const_lno_row_view_t _idx; // vertex degree list - const_lno_nnz_view_t _adj; // vertex adjacency list - const_clno_row_view_t _t_idx; // transpose vertex degree list - const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list - nnz_lno_t _chunk_size; - non_const_1d_size_type_view_t _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) + nnz_lno_type _num_verts; // num vertices + const_lno_row_view_type _idx; // vertex degree list + const_lno_nnz_view_t _adj; // vertex adjacency list + const_clno_row_view_t _t_idx; // transpose vertex degree list + const_clno_nnz_view_t _t_adj; // transpose vertex adjacency list + nnz_lno_type _chunk_size; + non_const_1d_size_type_view_type _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) // EXPERIMENTAL BEGIN pool_memory_space_t _m_space; - const nnz_lno_t _hash_size; - const nnz_lno_t _max_nonzeros; + const nnz_lno_type _hash_size; + const nnz_lno_type _max_nonzeros; Kokkos::Experimental::UniqueToken tokens; // EXPERIMENTAL END - functorCalculateD2Degree( nnz_lno_t num_verts - , const_lno_row_view_t xadj - , const_lno_nnz_view_t adj - , const_clno_row_view_t t_xadj - , const_clno_nnz_view_t t_adj - , nnz_lno_t chunk_size - , non_const_1d_size_type_view_t °ree_d2 - , pool_memory_space_t m_space - , const nnz_lno_t hash_size - , const nnz_lno_t max_nonzeros - ) + functorCalculateD2Degree(nnz_lno_type num_verts, + const_lno_row_view_type xadj, + const_lno_nnz_view_t adj, + const_clno_row_view_t t_xadj, + const_clno_nnz_view_t t_adj, + nnz_lno_type chunk_size, + non_const_1d_size_type_view_type& degree_d2, + pool_memory_space_t m_space, + const nnz_lno_type hash_size, + const nnz_lno_type max_nonzeros) : _num_verts(num_verts) - , _idx(xadj) - , _adj(adj) - , _t_idx(t_xadj) - , _t_adj(t_adj) - , _chunk_size(chunk_size) - , _degree_d2(degree_d2) - , _m_space(m_space) - , _hash_size(hash_size) - , _max_nonzeros(max_nonzeros) + , _idx(xadj) + , _adj(adj) + , _t_idx(t_xadj) + , _t_adj(t_adj) + , _chunk_size(chunk_size) + , _degree_d2(degree_d2) + , _m_space(m_space) + , _hash_size(hash_size) + , _max_nonzeros(max_nonzeros) { } KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t chunk_id) const + void operator()(const nnz_lno_type chunk_id) const { - #if 1 +#if 1 // EXPERIMENTAL // Get a unique token since we aren't using TeamPolicy (for UniformMemoryPool, that the HashmapAccumulator requires) auto tid = tokens.acquire(); - volatile nnz_lno_t * tmp = NULL; - while(NULL==tmp) - { - tmp = (volatile nnz_lno_t*)(_m_space.allocate_chunk(tid)); - } + volatile nnz_lno_type* tmp = NULL; + while(NULL == tmp) { tmp = (volatile nnz_lno_type*)(_m_space.allocate_chunk(tid)); } - KokkosKernels::Experimental::HashmapAccumulator hash_map; + KokkosKernels::Experimental::HashmapAccumulator hash_map; // What is globally_used_hash_indices? - nnz_lno_t *globally_used_hash_indices = (nnz_lno_t *) tmp; + nnz_lno_type* globally_used_hash_indices = (nnz_lno_type*)tmp; tmp += _hash_size; // set up hash_begins - hash_map.hash_begins = (nnz_lno_t *)(tmp); + hash_map.hash_begins = (nnz_lno_type*)(tmp); tmp += _hash_size; // set up hash_nexts - hash_map.hash_nexts = (nnz_lno_t *)(tmp); + hash_map.hash_nexts = (nnz_lno_type*)(tmp); tmp += _max_nonzeros; // set up hash_keys - hash_map.keys = (nnz_lno_t *)(tmp); + hash_map.keys = (nnz_lno_type*)(tmp); // Set key and value sizes - hash_map.hash_key_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table (unused?) - hash_map.max_value_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table + hash_map.hash_key_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table (unused?) + hash_map.max_value_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table - nnz_lno_t pow2_hash_func = _hash_size-1; - #endif + nnz_lno_type pow2_hash_func = _hash_size - 1; +#endif - for(nnz_lno_t ichunk = 0; ichunk < _chunk_size; ichunk++) + for(nnz_lno_type ichunk = 0; ichunk < _chunk_size; ichunk++) { - nnz_lno_t vid = chunk_id * _chunk_size + ichunk; + nnz_lno_type vid = chunk_id * _chunk_size + ichunk; - if(vid >= _num_verts) continue; + if(vid >= _num_verts) + continue; - nnz_lno_t used_hash_size = 0; - nnz_lno_t globally_used_hash_count = 0; + nnz_lno_type used_hash_size = 0; + nnz_lno_type globally_used_hash_count = 0; const size_type vid_d1_adj_begin = _idx(vid); const size_type vid_d1_adj_end = _idx(vid + 1); @@ -1544,17 +1592,17 @@ class GraphColorDistance2 // Loop over neighbors of vid (distance-1 from vid) for(size_type vid_d1_adj = vid_d1_adj_begin; vid_d1_adj < vid_d1_adj_end; ++vid_d1_adj) { - const nnz_lno_t vid_d1 = _adj(vid_d1_adj); - const size_type vid_d2_adj_begin = _t_idx(vid_d1); - const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); + const nnz_lno_type vid_d1 = _adj(vid_d1_adj); + const size_type vid_d2_adj_begin = _t_idx(vid_d1); + const size_type vid_d2_adj_end = _t_idx(vid_d1 + 1); // EXPERIMENTAL BEGIN for(size_type vid_d2_adj = vid_d2_adj_begin; vid_d2_adj < vid_d2_adj_end; ++vid_d2_adj) { - const nnz_lno_t vid_d2 = _t_adj(vid_d2_adj); + const nnz_lno_type vid_d2 = _t_adj(vid_d2_adj); - nnz_lno_t hash = vid_d2 & pow2_hash_func; + nnz_lno_type hash = vid_d2 & pow2_hash_func; int r = hash_map.sequential_insert_into_hash_TrackHashes(hash, vid_d2, @@ -1572,26 +1620,26 @@ class GraphColorDistance2 // EXPERIMENTAL END } // for vid_d1_adj ... - // EXPERIMENTAL BEGIN - #if 1 - //std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; +// EXPERIMENTAL BEGIN +#if 1 + // std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; _degree_d2(vid) = used_hash_size; // Clear the Begins values. - for(nnz_lno_t i=0; i < globally_used_hash_count; i++) + for(nnz_lno_type i = 0; i < globally_used_hash_count; i++) { - nnz_lno_t dirty_hash = globally_used_hash_indices[i]; - hash_map.hash_begins[dirty_hash] = -1; + nnz_lno_type dirty_hash = globally_used_hash_indices[ i ]; + hash_map.hash_begins[ dirty_hash ] = -1; } - #endif +#endif // EXPERIMENTAL END - } // for ichunk ... + } // for ichunk ... _m_space.release_chunk(globally_used_hash_indices); - } // operator() (end) - }; // struct functorCalculateD2Degree (end) + } // operator() (end) + }; // struct functorCalculateD2Degree (end) -}; // end class GraphColorDistance2 +}; // end class GraphColorDistance2 } // namespace Impl From fa828f02de04fbd6800745a3f201c53697dc7e87 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 Jan 2019 11:41:50 -0700 Subject: [PATCH 099/190] ColoringD2 Fix shadowed variable error --- .../impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 23cd63b955..208d670596 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -130,7 +130,7 @@ class GraphColorDistance2MatrixSquared const_lno_nnz_view_type entries, const_clno_row_view_type t_row_map, const_clno_nnz_view_type t_entries, - HandleType* handle) + HandleType* handle_) : nr(nr_) , nc(nc_) , ne(ne_) @@ -139,8 +139,8 @@ class GraphColorDistance2MatrixSquared , t_xadj(t_row_map) , t_adj(t_entries) , nv(nr_) - , handle(handle) - , verbose(handle->get_verbose()) + , handle(handle_) + , verbose(handle_->get_verbose()) { } From b46623036e64d7de0708e8d15ae294d64e0a93c6 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 Jan 2019 16:34:46 -0700 Subject: [PATCH 100/190] D2 Coloring Cleanup Commenting out a check I had put in on the Distance-1 graph coloring handle getter where I threw an error if the user tried to get the graph-coloring handle before it had been created. I commented that out for now since the GCHandle use-case in SPGEMM is to get the pointer before it's created. I tend to think this pattern opens the door for hard-to-find errors but baking that into the getter might involve mucking around in SPGEMM, which is complicated. --- src/common/KokkosKernels_Handle.hpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index ac8ed1b894..14f7b00342 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -406,10 +406,15 @@ class KokkosKernelsHandle // Distance-1 Graph Coloring GraphColoringHandleType *get_graph_coloring_handle(){ - if(!this->is_owner_of_the_gc_handle) - { - throw std::runtime_error("Graph coloring handle has not been created."); - } + // (wcmclen): Should there be a check here to make sure we've created a GC handle before + // handing the pointer out to something? This is disabled for now because it + // gets thrown in tests run by spot check. Moving forward, we should consider + // whether a "get the handle ptr, then allocate" vs. "only give out the handle ptr + // if it actually exists" model. + //if(!this->is_owner_of_the_gc_handle) + //{ + // throw std::runtime_error("Graph coloring handle has not been created."); + //} return this->gcHandle; } void create_graph_coloring_handle(KokkosGraph::ColoringAlgorithm coloring_type = KokkosGraph::COLORING_DEFAULT){ From 396a34f0bdd754be0241c028f93106219c558d67 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 Jan 2019 18:13:24 -0700 Subject: [PATCH 101/190] bug fix on D2 coloring for cuda --- src/graph/KokkosGraph_Distance2Color.hpp | 8 ++++---- src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp | 4 +++- unit_test/graph/Test_Graph_graph_color_distance2.hpp | 2 +- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index c7b998b304..3617adf72e 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -112,7 +112,7 @@ void graph_compute_distance2_color(KernelHandle *handle, { // todo: The original Serial D2 coloring code is in GraphColorHandle. This should get moved to the // distance-2 coloring handle but that might break backwards compatibility. - #if defined KOKKOS_ENABLE_SERIAL +// #if defined KOKKOS_ENABLE_SERIAL int num_phases = 0; typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); @@ -126,9 +126,9 @@ void graph_compute_distance2_color(KernelHandle *handle, gch_d2->set_vertex_colors(colors_out); gch_d2->set_num_phases((double)num_phases); - #else - throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); - #endif +// #else +// throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); +// #endif } break; diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index 6bd3446012..a7f8a4fb3a 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -516,7 +516,9 @@ void KokkosGraph::Experimental::d2_graph_color (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); - // WCMCLEN: SCAFFOLDING / EXPERIMENTAL + // WCMCLEN: EXPERIMENTAL - We should switch this to use the distance-2 graph coloring handle at + // some point, but it might not be 'simple' since this is being used in + // the SPGEMM code. // handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); // KokkosGraph::Experimental::graph_compute_distance2_color // (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); diff --git a/unit_test/graph/Test_Graph_graph_color_distance2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp index 7b70be0e47..3cadb004df 100644 --- a/unit_test/graph/Test_Graph_graph_color_distance2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -196,7 +196,7 @@ test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type r cp.destroy_spgemm_handle(); GraphColoringAlgorithmDistance2 coloring_algorithms[] = { - COLORING_D2_MATRIX_SQUARED, COLORING_D2_SERIAL, COLORING_D2, COLORING_D2_VB, COLORING_D2_VB_BIT}; + COLORING_D2_MATRIX_SQUARED, COLORING_D2_SERIAL, COLORING_D2, COLORING_D2_VB, COLORING_D2_VB_BIT, COLORING_D2_VB_BIT_EF}; int num_algorithms = 5; From 20826fbf5651240d3446a42b57eda871ceb2e1de Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 24 Jan 2019 18:51:22 -0700 Subject: [PATCH 102/190] D2 graph coloring: add in header wrapper for backwards compatibility --- src/graph/KokkosGraph_graph_color.hpp | 52 +++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 src/graph/KokkosGraph_graph_color.hpp diff --git a/src/graph/KokkosGraph_graph_color.hpp b/src/graph/KokkosGraph_graph_color.hpp new file mode 100644 index 0000000000..26b4ac3bb7 --- /dev/null +++ b/src/graph/KokkosGraph_graph_color.hpp @@ -0,0 +1,52 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +/** + * This maintains backwards-compatibility with older code that included + * the KokkosGraph_graph_color.hpp file. The new file is renamed to + * KokkosGraph_GraphColor.hpp to be more consistent with file naming + * used in other places within Kokkos-Kernels. + */ +#include "KokkosGraph_GraphColor.hpp" + From f8f118cfdb055430ec800c61c356c14dfb3e3599 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 29 Jan 2019 10:43:06 -0700 Subject: [PATCH 103/190] Use homebrew's coreutils cp if available on osx If the `coreutils` package is installed on OSX via Homebrew, there will be a gnu version of cp installed which does respect the `-u` option. This will greatly reduce the time it takes to recompile KokkosKernels on OSX systems since we won't be updating the timestamp on all the sources every time we recompile. --- Makefile.kokkos-kernels | 11 ++++++++++- src/Makefile | 28 ++++++++++++++-------------- 2 files changed, 24 insertions(+), 15 deletions(-) diff --git a/Makefile.kokkos-kernels b/Makefile.kokkos-kernels index 49b26befc0..274cd2ef85 100644 --- a/Makefile.kokkos-kernels +++ b/Makefile.kokkos-kernels @@ -456,6 +456,8 @@ endif DEPFLAGS = -M +CP = cp + ifeq ($(KOKKOS_OS),CYGWIN) COPY_FLAG = -u endif @@ -463,7 +465,14 @@ ifeq ($(KOKKOS_OS),Linux) COPY_FLAG = -u endif ifeq ($(KOKKOS_OS),Darwin) - COPY_FLAG = + # If using Homebrew on OSX with the 'coreutils' package installed + # we have a gnu version of cp which has the -u option + ifeq (,$(wildcard "/usr/local/opt/coreutils/libexec/gnubin/cp")) + CP = /usr/local/opt/coreutils/libexec/gnubin/cp + COPY_FLAG = -u + else + COPY_FLAG = + endif endif KOKKOSKERNELS_INTERNAL_SRC_BLAS_NODIR = $(notdir $(KOKKOSKERNELS_INTERNAL_SRC_BLAS)) diff --git a/src/Makefile b/src/Makefile index de1d3d9cfc..67070a296a 100644 --- a/src/Makefile +++ b/src/Makefile @@ -74,20 +74,20 @@ kokkoskernels-install: kokkoskernels-build-lib echo "KOKKOS_INTERNAL_USE_ROCM = ${KOKKOS_INTERNAL_USE_ROCM}" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "# Fake target" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "libkokkos_kernels.a:" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels - cp $(COPY_FLAG) KokkosKernels_config.h $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/blas/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/blas/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/batched/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/sparse/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/sparse/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/graph/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/graph/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/common/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) -r ${KOKKOSKERNELS_PATH}/src/impl/generated_specializations_hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/impl/tpls/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include - cp $(COPY_FLAG) $(KOKKOSKERNELS_INTERNAL_LIBRARY) $(KOKKOSKERNELS_INSTALL_PATH)/lib + $(CP) $(COPY_FLAG) KokkosKernels_config.h $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/blas/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/blas/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/batched/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/sparse/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/sparse/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/graph/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/graph/impl/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/common/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) -r ${KOKKOSKERNELS_PATH}/src/impl/generated_specializations_hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) ${KOKKOSKERNELS_PATH}/src/impl/tpls/*.hpp $(KOKKOSKERNELS_INSTALL_PATH)/include + $(CP) $(COPY_FLAG) $(KOKKOSKERNELS_INTERNAL_LIBRARY) $(KOKKOSKERNELS_INSTALL_PATH)/lib build: kokkoskernels-build-lib From d7a0f6a6b47ad515597c27e721a64014b1e9aad4 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 30 Jan 2019 10:14:17 -0700 Subject: [PATCH 104/190] Cleaning up D2 Coloring test --- src/graph/KokkosGraph_Distance2Color.hpp | 30 ++++++------- src/graph/KokkosGraph_GraphColor.hpp | 11 +---- .../KokkosGraph_GraphColorDistance2Handle.hpp | 7 ++- src/graph/KokkosGraph_GraphColorHandle.hpp | 8 ---- .../impl/KokkosGraph_Distance2Color_impl.hpp | 21 +++++---- .../Test_Graph_graph_color_distance2.hpp | 43 ++++++++++++++++++- 6 files changed, 72 insertions(+), 48 deletions(-) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 3617adf72e..e21f61c835 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -100,6 +100,7 @@ void graph_compute_distance2_color(KernelHandle *handle, switch(algorithm) { case COLORING_D2_MATRIX_SQUARED: + case COLORING_D2_SPGEMM: { Impl::GraphColorDistance2MatrixSquared gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, handle); @@ -112,23 +113,18 @@ void graph_compute_distance2_color(KernelHandle *handle, { // todo: The original Serial D2 coloring code is in GraphColorHandle. This should get moved to the // distance-2 coloring handle but that might break backwards compatibility. -// #if defined KOKKOS_ENABLE_SERIAL - int num_phases = 0; + int num_phases = 0; - typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); + typename KernelHandle::GraphColoringHandleType *gch_d1 = handle->get_graph_coloring_handle(); - Impl::GraphColor - gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); + Impl::GraphColor + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch_d1); - gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); + gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); - // Save out the number of phases and vertex colors - gch_d2->set_vertex_colors(colors_out); - gch_d2->set_num_phases((double)num_phases); - -// #else -// throw std::runtime_error("Kokkos-Kernels must be built with Serial enabled to use COLORING_D2_SERIAL"); -// #endif + // Save out the number of phases and vertex colors + gch_d2->set_vertex_colors(colors_out); + gch_d2->set_num_phases((double)num_phases); } break; @@ -162,10 +158,11 @@ void graph_compute_distance2_color(KernelHandle *handle, /** * Compute Distance-2 Degree Stats * - * Distance-2 Degree of a vertex, v, is the sum of the degree of all neighbors of v. + * Distance-2 Degree of a vertex, v, is the sum of the unique paths from u to v + * where v is 2 hops from u. (i.e., paths like: `u -> * -> v`) * * This function calculates the distance-2 degree of all the vertices in the graph, - * the maximum distance-2 degree, and the sum of all the distance-2 degrees. + * the maximum distance-2 degree. * * If the graph is symmetric, give the same value for col_map and row_map, * and for row_entries and col_entries. @@ -179,9 +176,10 @@ void graph_compute_distance2_color(KernelHandle *handle, * @param[in] col_entries Column entries * @param[out] degree_d2_dist View to fill with distance-2 degree information. * @param[out] degree_d2_max Maximum distance-2 degree found. - * @param[out] degree_d2_sum Sum of all distance-2 degrees. * * @return Nothing + * + * Note: This is currently EXPERIMENTAL. */ template void graph_compute_distance2_degree(KernelHandle *handle, diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_GraphColor.hpp index ec24ee2cbe..999edf7d8f 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_GraphColor.hpp @@ -86,12 +86,6 @@ void graph_color_symbolic( gc = new BaseGraphColoring(num_rows, entries.extent(0), row_map, entries, gch); break; -// case COLORING_SERIAL2: -// gc = new Impl::GraphColor2( -// num_rows, entries.extent(0), -// row_map, entries, gch); -// break; - case COLORING_VB: case COLORING_VBBIT: case COLORING_VBCS: @@ -164,10 +158,7 @@ void d2_graph_color( typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; - //color_view_type colors_out = color_view_type("Graph Colors", num_rows); - - typedef typename Impl::GraphColor BaseGraphColoring; - //BaseGraphColoring *gc = NULL; + typedef typename Impl::GraphColorBaseGraphColoring; int num_phases = 0; diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index d2d49951e5..67f61afb82 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -59,6 +59,7 @@ enum GraphColoringAlgorithmDistance2 COLORING_D2_DEFAULT, // Distance-2 Graph Coloring default algorithm COLORING_D2_SERIAL, // Distance-2 Graph Coloring (SERIAL) COLORING_D2_MATRIX_SQUARED, // Distance-2 Graph Coloring using Matrix Squared + D1 Coloring + COLORING_D2_SPGEMM, // - Same as COLORING_D2_MATRIX_SQUARED COLORING_D2, // Distance-2 Graph Coloring COLORING_D2_VB, // Distance-2 Graph Coloring Vertex Based COLORING_D2_VB_BIT, // Distance-2 Graph Coloring Vertex Based BIT @@ -125,9 +126,6 @@ class GraphColorDistance2Handle int num_phases; // Number of phases used by the coloring algorithm - - size_type size_of_edge_list; // todo not used? - color_view_type vertex_colors; bool is_coloring_called_before; nnz_lno_type num_colors; @@ -153,7 +151,6 @@ class GraphColorDistance2Handle , overall_coloring_time_phase5(0) , coloring_time(0) , num_phases(0) - , size_of_edge_list(0) , vertex_colors() , is_coloring_called_before(false) , num_colors(0) @@ -324,6 +321,8 @@ class GraphColorDistance2Handle bool is_coloring_called() const { return this->is_coloring_called_before; } // setters + void set_coloring_called() { this->is_coloring_called_before = true; } + void set_coloring_algo_type(const GraphColoringAlgorithmDistance2& col_algo) { this->coloring_algorithm_type = col_algo; } void set_verbose(const bool verbose_) { this->verbose = verbose_; } diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 363831c7c8..9ad029a762 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -627,14 +627,6 @@ class GraphColoringHandle case COLORING_VBD: case COLORING_VBDBIT: case COLORING_SERIAL: -// case COLORING_SERIAL2: -// case COLORING_SPGEMM: -// case COLORING_D2_MATRIX_SQUARED: -// case COLORING_D2_SERIAL: -// case COLORING_D2: -// case COLORING_D2_VB: -// case COLORING_D2_VB_BIT: -// case COLORING_D2_VB_BIT_EF: this->conflict_list_type = COLORING_ATOMIC; this->min_reduction_for_conflictlist = 0.35; this->min_elements_for_conflictlist = 1000; diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 58954e8155..c9a7ac63b9 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -234,7 +234,7 @@ class GraphColorDistance2 */ } -#if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation + #if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation // Compute Distance-2 Degree of the vertices. // -- Keeping this around in case we need to use it later on as an example. size_t degree_d2_max=0; @@ -247,7 +247,7 @@ class GraphColorDistance2 std::cout << ">>> Max D2 Degree: " << degree_d2_max << std::endl; std::cout << ">>> D2 Degree Sum: " << degree_d2_sum<< std::endl; } -#endif + #endif // conflictlist - store conflicts that can happen when we're coloring in parallel. nnz_lno_temp_work_view_t current_vertexList = @@ -593,6 +593,9 @@ class GraphColorDistance2 KOKKOS_LAMBDA(const size_t& i, size_t & lmax) { lmax = degree_d2(i) > lmax ? degree_d2(i) : lmax; }, Kokkos::Max(_degree_d2_max)); degree_d2_max = _degree_d2_max; + + // Tell the handle that coloring has been called. + this->gc_handle->set_coloring_called(); } @@ -1509,7 +1512,7 @@ class GraphColorDistance2 nnz_lno_type _chunk_size; non_const_1d_size_type_view_type _degree_d2; // Distance-2 Degree (assumes all are initialized to 0) - // EXPERIMENTAL BEGIN + // EXPERIMENTAL BEGIN (for HashMapAccumulator) pool_memory_space_t _m_space; const nnz_lno_type _hash_size; const nnz_lno_type _max_nonzeros; @@ -1544,7 +1547,7 @@ class GraphColorDistance2 KOKKOS_INLINE_FUNCTION void operator()(const nnz_lno_type chunk_id) const { -#if 1 + #if 1 // EXPERIMENTAL // Get a unique token since we aren't using TeamPolicy (for UniformMemoryPool, that the HashmapAccumulator requires) auto tid = tokens.acquire(); @@ -1574,7 +1577,7 @@ class GraphColorDistance2 hash_map.max_value_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table nnz_lno_type pow2_hash_func = _hash_size - 1; -#endif + #endif for(nnz_lno_type ichunk = 0; ichunk < _chunk_size; ichunk++) { @@ -1620,8 +1623,9 @@ class GraphColorDistance2 // EXPERIMENTAL END } // for vid_d1_adj ... -// EXPERIMENTAL BEGIN -#if 1 + // EXPERIMENTAL BEGIN + #if 1 + // std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; _degree_d2(vid) = used_hash_size; @@ -1631,8 +1635,9 @@ class GraphColorDistance2 nnz_lno_type dirty_hash = globally_used_hash_indices[ i ]; hash_map.hash_begins[ dirty_hash ] = -1; } -#endif + #endif // EXPERIMENTAL END + } // for ichunk ... _m_space.release_chunk(globally_used_hash_indices); } // operator() (end) diff --git a/unit_test/graph/Test_Graph_graph_color_distance2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp index 3cadb004df..8688f18077 100644 --- a/unit_test/graph/Test_Graph_graph_color_distance2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -93,13 +93,48 @@ run_graphcolor_d2(crsMat_type const size_t num_rows_1 = input_mat.numRows(); const size_t num_cols_1 = input_mat.numCols(); + // Compute the Distance-2 graph coloring. graph_compute_distance2_color (&kh, num_rows_1, num_cols_1, input_mat.graph.row_map, input_mat.graph.entries, input_mat.graph.row_map, input_mat.graph.entries); num_colors = kh.get_distance2_graph_coloring_handle()->get_num_colors(); vertex_colors = kh.get_distance2_graph_coloring_handle()->get_vertex_colors(); + + // Verify the Distance-2 graph coloring is valid. + bool d2_coloring_is_valid = false; + bool d2_coloring_validation_flags[4] = { false }; + + d2_coloring_is_valid = graph_verify_distance2_color(&kh, num_rows_1, num_cols_1, + input_mat.graph.row_map,input_mat.graph.entries, + input_mat.graph.row_map, input_mat.graph.entries, + d2_coloring_validation_flags); + + + + // Print out messages based on coloring validation check. + if(d2_coloring_is_valid) + { + std::cout << std::endl << "Distance-2 Graph Coloring is VALID" << std::endl << std::endl; + } + else + { + std::cout << std::endl + << "Distance-2 Graph Coloring is NOT VALID" << std::endl + << " - Vert(s) left uncolored : " << d2_coloring_validation_flags[1] << std::endl + << " - Invalid D2 Coloring : " << d2_coloring_validation_flags[2] << std::endl + << std::endl; + } + if(d2_coloring_validation_flags[3]) + { + std::cout << "Distance-2 Graph Coloring may have poor quality." << std::endl + << " - Vert(s) have high color value : " << d2_coloring_validation_flags[3] << std::endl + << std::endl; + } + kh.destroy_distance2_graph_coloring_handle(); - return 0; + + // return 0 if the coloring is valid, 1 otherwise. + return d2_coloring_is_valid ? 0 : 1; } } // namespace Test @@ -198,7 +233,7 @@ test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type r GraphColoringAlgorithmDistance2 coloring_algorithms[] = { COLORING_D2_MATRIX_SQUARED, COLORING_D2_SERIAL, COLORING_D2, COLORING_D2_VB, COLORING_D2_VB_BIT, COLORING_D2_VB_BIT_EF}; - int num_algorithms = 5; + int num_algorithms = 6; for(int ii = 0; ii < num_algorithms; ++ii) { @@ -210,9 +245,11 @@ test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type r Kokkos::Impl::Timer timer1; crsMat_type output_mat; int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); + // double coloring_time = timer1.seconds(); EXPECT_TRUE((res == 0)); + #if 0 // no need to check distance-1 coloring for validity. const lno_type num_rows_1 = input_mat.numRows(); const lno_type num_cols_1 = input_mat.numCols(); @@ -251,6 +288,8 @@ test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type r EXPECT_TRUE((num_conflict == conf)); EXPECT_TRUE((num_conflict == 0)); + #endif + /* ::testing::internal::CaptureStdout(); std::cout << "num_colors:" << num_colors << " num_conflict:" << num_conflict << " conf:" << conf << std::endl; From 0417948cc5c91d4b004b31345eca49d45004dabc Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 30 Jan 2019 10:51:52 -0700 Subject: [PATCH 105/190] D2 Coloring test cleanup --- .../Test_Graph_graph_color_distance2.hpp | 51 ------------------- 1 file changed, 51 deletions(-) diff --git a/unit_test/graph/Test_Graph_graph_color_distance2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp index 8688f18077..a638fc406f 100644 --- a/unit_test/graph/Test_Graph_graph_color_distance2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -246,59 +246,8 @@ test_coloring_d2(lno_type numRows, size_type nnz, lno_type bandwidth, lno_type r crsMat_type output_mat; int res = run_graphcolor_d2(input_mat, coloring_algorithm, num_colors, vector_colors); - // double coloring_time = timer1.seconds(); EXPECT_TRUE((res == 0)); - - #if 0 // no need to check distance-1 coloring for validity. - const lno_type num_rows_1 = input_mat.numRows(); - const lno_type num_cols_1 = input_mat.numCols(); - - lno_type num_conflict = KokkosKernels::Impl:: - kk_is_d1_coloring_valid( - num_rows_1, num_cols_1, cRowptrs, cColinds, vector_colors); - - lno_type conf = 0; - { - // also check the correctness of the validation code :) - typename lno_view_type::HostMirror hrm = Kokkos::create_mirror_view(cRowptrs); - typename lno_nnz_view_type::HostMirror hentries = Kokkos::create_mirror_view(cColinds); - typename color_view_type::HostMirror hcolor = Kokkos::create_mirror_view(vector_colors); - Kokkos::deep_copy(hrm, cRowptrs); - Kokkos::deep_copy(hentries, cColinds); - Kokkos::deep_copy(hcolor, vector_colors); - - for(lno_type i = 0; i < num_rows_1; ++i) - { - const size_type b = hrm(i); - const size_type e = hrm(i + 1); - for(size_type j = b; j < e; ++j) - { - lno_type d = hentries(j); - if(i != d) - { - if(hcolor(d) == hcolor(i)) - { - conf++; - } - } - } - } - } - - EXPECT_TRUE((num_conflict == conf)); - - EXPECT_TRUE((num_conflict == 0)); - #endif - - /* - ::testing::internal::CaptureStdout(); - std::cout << "num_colors:" << num_colors << " num_conflict:" << num_conflict << " conf:" << conf << std::endl; - std::string capturedStdout = ::testing::internal::GetCapturedStdout().c_str(); - EXPECT_STREQ("something", capturedStdout.c_str()); - */ } - - // device::execution_space::finalize(); } #define EXECUTE_TEST(SCALAR, ORDINAL, OFFSET, DEVICE) \ From 68fd973ef8e3c659a8d0031505c806957eecc2ad Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 7 Feb 2019 11:37:33 -0700 Subject: [PATCH 106/190] KokkosBatched - add sime specialization for cuda --- src/batched/KokkosBatched_Vector.hpp | 46 +++- src/batched/KokkosBatched_Vector_SIMD.hpp | 215 +++++++++++++----- .../KokkosBatched_Vector_SIMD_Arith.hpp | 48 +++- .../KokkosBatched_Vector_SIMD_Logical.hpp | 14 +- .../KokkosBatched_Vector_SIMD_Math.hpp | 40 ++-- .../KokkosBatched_Vector_SIMD_Misc.hpp | 28 +-- .../KokkosBatched_Vector_SIMD_Relation.hpp | 6 +- 7 files changed, 292 insertions(+), 105 deletions(-) diff --git a/src/batched/KokkosBatched_Vector.hpp b/src/batched/KokkosBatched_Vector.hpp index d13c2d4172..b3d5fb29af 100644 --- a/src/batched/KokkosBatched_Vector.hpp +++ b/src/batched/KokkosBatched_Vector.hpp @@ -19,7 +19,7 @@ namespace KokkosBatched { struct DefaultVectorLength { enum : int { value = 1 }; }; - + template<> struct DefaultVectorLength { #if defined(__AVX512F__) @@ -96,6 +96,50 @@ namespace KokkosBatched { }; #endif + template + struct DefaultInternalVectorLength { + enum : int { value = 1 }; + }; + template + struct DefaultInternalVectorLength { + enum : int { value = DefaultVectorLength::value }; + }; + +#if defined(KOKKOS_ENABLE_CUDA) + template<> + struct DefaultInternalVectorLength { + enum : int { value = 4 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaSpace> { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaSpace> { + enum : int { value = 1 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 4 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 1 }; + }; +#endif + template struct MagnitudeScalarType; diff --git a/src/batched/KokkosBatched_Vector_SIMD.hpp b/src/batched/KokkosBatched_Vector_SIMD.hpp index 5ce5c2426f..1796b493c1 100644 --- a/src/batched/KokkosBatched_Vector_SIMD.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD.hpp @@ -38,7 +38,12 @@ namespace KokkosBatched { using mag_type = typename Kokkos::Details::ArithTraits::mag_type; enum : int { vector_length = l }; + +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; +#else typedef value_type data_type[vector_length]; +#endif KOKKOS_INLINE_FUNCTION static const char* label() { return "SIMD"; } @@ -125,8 +130,99 @@ namespace KokkosBatched { return _data[i]; } }; + } +} + + +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) +namespace KokkosBatched { + namespace Experimental { + + template<> + class Vector,2> { + public: + using type = Vector,2>; + using value_type = double; + using mag_type = double; + + enum : int { vector_length = 2 }; + //typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; + typedef double2 data_type; + + KOKKOS_INLINE_FUNCTION + static const char* label() { return "CudaDouble2"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; } + KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; } + KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; } + KOKKOS_INLINE_FUNCTION Vector(const double2 &val) { _data.x = val.x; _data.y = val.y; } + + template + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + _data.x = val; + _data.y = val; + } + + template + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + _data.x = b[0]; + _data.y = b[1]; + } + + KOKKOS_INLINE_FUNCTION + type& operator=(const double2 &val) { + _data.x = val.x; + _data.y = val.y; + return *this; + } + + KOKKOS_INLINE_FUNCTION + double2 double2() const { + return _data; + } + + KOKKOS_INLINE_FUNCTION + type& loadAligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + type& loadUnaligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + void storeAligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + void storeUnaligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + value_type& operator[](const int &i) const { + return reinterpret_cast(&_data)[i]; + } + }; + } +} +#endif -}} #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX__) || defined(__AVX2__) @@ -145,7 +241,7 @@ namespace KokkosBatched { enum : int { vector_length = 4 }; typedef __m256d data_type __attribute__ ((aligned(32))); - KOKKOS_INLINE_FUNCTION + inline static const char* label() { return "AVX256"; } template @@ -155,13 +251,13 @@ namespace KokkosBatched { mutable data_type _data; public: - KOKKOS_INLINE_FUNCTION Vector() { _data = _mm256_setzero_pd(); } - KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data = _mm256_set1_pd(val); } - KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data = b._data; } - KOKKOS_INLINE_FUNCTION Vector(const __m256d &val) { _data = val; } + inline Vector() { _data = _mm256_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm256_set1_pd(val); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m256d &val) { _data = val; } template - KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + inline Vector(const ArgValueType &val) { auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep @@ -174,7 +270,7 @@ namespace KokkosBatched { } template - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + inline Vector(const Vector,vector_length> &b) { auto dd = reinterpret_cast(&_data); auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) @@ -187,40 +283,40 @@ namespace KokkosBatched { dd[i] = bb[i]; } - KOKKOS_INLINE_FUNCTION + inline type& operator=(const __m256d &val) { _data = val; return *this; } - KOKKOS_INLINE_FUNCTION + inline operator __m256d() const { return _data; } - KOKKOS_INLINE_FUNCTION + inline type& loadAligned(const value_type *p) { _data = _mm256_load_pd(p); return *this; } - KOKKOS_INLINE_FUNCTION + inline type& loadUnaligned(const value_type *p) { _data = _mm256_loadu_pd(p); return *this; } - KOKKOS_INLINE_FUNCTION + inline void storeAligned(value_type *p) const { _mm256_store_pd(p, _data); } - KOKKOS_INLINE_FUNCTION + inline void storeUnaligned(value_type *p) const { _mm256_storeu_pd(p, _data); } - KOKKOS_INLINE_FUNCTION + inline value_type& operator[](const int &i) const { return reinterpret_cast(&_data)[i]; } @@ -236,7 +332,7 @@ namespace KokkosBatched { static const int vector_length = 2; typedef __m256d data_type __attribute__ ((aligned(32))); - KOKKOS_INLINE_FUNCTION + inline static const char* label() { return "AVX256"; } template @@ -246,14 +342,14 @@ namespace KokkosBatched { mutable data_type _data; public: - KOKKOS_INLINE_FUNCTION Vector() { _data = _mm256_setzero_pd(); } - KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data = _mm256_broadcast_pd((const __m128d *)&val);} - KOKKOS_INLINE_FUNCTION Vector(const mag_type &val) { const value_type a(val); _data = _mm256_broadcast_pd((__m128d const *)&a); } - KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data = b._data; } - KOKKOS_INLINE_FUNCTION Vector(const __m256d &val) { _data = val; } + inline Vector() { _data = _mm256_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm256_broadcast_pd((const __m128d *)&val);} + inline Vector(const mag_type &val) { const value_type a(val); _data = _mm256_broadcast_pd((__m128d const *)&a); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m256d &val) { _data = val; } // template -// KOKKOS_INLINE_FUNCTION Vector(const ArgValueType val) { +// inline Vector(const ArgValueType val) { // #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) // #pragma ivdep // #endif @@ -264,7 +360,7 @@ namespace KokkosBatched { // _data.d[i] = value_type(val); // } template - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + inline Vector(const Vector,vector_length> &b) { auto dd = reinterpret_cast(&_data); auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) @@ -277,40 +373,40 @@ namespace KokkosBatched { dd[i] = bb[i]; } - KOKKOS_INLINE_FUNCTION + inline type& operator=(const __m256d &val) { _data = val; return *this; } - KOKKOS_INLINE_FUNCTION + inline operator __m256d() const { return _data; } - KOKKOS_INLINE_FUNCTION + inline type& loadAligned(const value_type *p) { _data = _mm256_load_pd((mag_type*)p); return *this; } - KOKKOS_INLINE_FUNCTION + inline type& loadUnaligned(const value_type *p) { _data = _mm256_loadu_pd((mag_type*)p); return *this; } - KOKKOS_INLINE_FUNCTION + inline void storeAligned(value_type *p) const { _mm256_store_pd((mag_type*)p, _data); } - KOKKOS_INLINE_FUNCTION + inline void storeUnaligned(value_type *p) const { _mm256_storeu_pd((mag_type*)p, _data); } - KOKKOS_INLINE_FUNCTION + inline value_type& operator[](const int &i) const { return reinterpret_cast(&_data)[i]; } @@ -341,13 +437,13 @@ namespace KokkosBatched { mutable data_type _data; public: - KOKKOS_INLINE_FUNCTION Vector() { _data = _mm512_setzero_pd(); } - KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data = _mm512_set1_pd(val); } - KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data = b._data; } - KOKKOS_INLINE_FUNCTION Vector(const __m512d &val) { _data = val; } + inline Vector() { _data = _mm512_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm512_set1_pd(val); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m512d &val) { _data = val; } template - KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + inline Vector(const ArgValueType &val) { auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep @@ -359,7 +455,7 @@ namespace KokkosBatched { d[i] = val; } template - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + inline Vector(const Vector,vector_length> &b) { auto dd = reinterpret_cast(&_data); auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) @@ -372,40 +468,40 @@ namespace KokkosBatched { dd[i] = bb[i]; } - KOKKOS_INLINE_FUNCTION + inline type& operator=(const __m512d &val) { _data = val; return *this; } - KOKKOS_INLINE_FUNCTION + inline operator __m512d() const { return _data; } - KOKKOS_INLINE_FUNCTION + inline type& loadAligned(const value_type *p) { _data = _mm512_load_pd(p); return *this; } - KOKKOS_INLINE_FUNCTION + inline type& loadUnaligned(const value_type *p) { _data = _mm512_loadu_pd(p); return *this; } - KOKKOS_INLINE_FUNCTION + inline void storeAligned(value_type *p) const { _mm512_store_pd(p, _data); } - KOKKOS_INLINE_FUNCTION + inline void storeUnaligned(value_type *p) const { _mm512_storeu_pd(p, _data); } - KOKKOS_INLINE_FUNCTION + inline value_type& operator[](const int &i) const { return reinterpret_cast(&_data)[i]; } @@ -421,7 +517,7 @@ namespace KokkosBatched { enum : int { vector_length = 4 }; typedef __m512d data_type __attribute__ ((aligned(64))); - KOKKOS_INLINE_FUNCTION + inline static const char* label() { return "AVX512"; } template @@ -431,18 +527,18 @@ namespace KokkosBatched { mutable data_type _data; public: - KOKKOS_INLINE_FUNCTION Vector() { _data = _mm512_setzero_pd(); } - KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { + inline Vector() { _data = _mm512_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm512_mask_broadcast_f64x4(_mm512_set1_pd(val.imag()), 0x55, _mm256_set1_pd(val.real())); } - KOKKOS_INLINE_FUNCTION Vector(const mag_type &val) { + inline Vector(const mag_type &val) { _data = _mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, _mm256_set1_pd(val)); } - KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data = b._data; } - KOKKOS_INLINE_FUNCTION Vector(const __m512d &val) { _data = val; } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m512d &val) { _data = val; } template - KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + inline Vector(const ArgValueType &val) { auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep @@ -454,7 +550,7 @@ namespace KokkosBatched { d[i] = val; } template - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + inline Vector(const Vector,vector_length> &b) { auto dd = reinterpret_cast(&_data); auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) @@ -467,45 +563,46 @@ namespace KokkosBatched { dd[i] = bb[i]; } - KOKKOS_INLINE_FUNCTION + inline type& operator=(const __m512d &val) { _data = val; return *this; } - KOKKOS_INLINE_FUNCTION + inline operator __m512d() const { return _data; } - KOKKOS_INLINE_FUNCTION + inline type& loadAligned(const value_type *p) { _data = _mm512_load_pd((mag_type*)p); return *this; } - KOKKOS_INLINE_FUNCTION + inline type& loadUnaligned(const value_type *p) { _data = _mm512_loadu_pd((mag_type*)p); return *this; } - KOKKOS_INLINE_FUNCTION + inline void storeAligned(value_type *p) const { _mm512_store_pd((mag_type*)p, _data); } - KOKKOS_INLINE_FUNCTION + inline void storeUnaligned(value_type *p) const { _mm512_storeu_pd((mag_type*)p, _data); } - KOKKOS_INLINE_FUNCTION + inline value_type& operator[](const int &i) const { return reinterpret_cast(&_data)[i]; } }; -}} + } +} #endif /* #if defined(__AVX512F__) */ #endif /* #if defined(__KOKKOSBATCHED_ENABLE_AVX__) */ diff --git a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp index 3a559d0d3c..f912a777e5 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp @@ -68,7 +68,19 @@ namespace KokkosBatched { r_val[i] = a[i] + b[i]; return r_val; } - + +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) + operator + (const Vector,2> &a, const Vector,2> &b) { + double2 r_val; + r_val.x = a.double2().x + b.double2().x; + r_val.y = a.double2().y + b.double2().y; + return r_val; + } +#endif + template KOKKOS_FORCEINLINE_FUNCTION static @@ -238,6 +250,17 @@ namespace KokkosBatched { return r_val; } +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) + operator - (const Vector,2> &a, const Vector,2> &b) { + double2 r_val; + r_val.x = a.double2().x - b.double2().x; + r_val.y = a.double2().y - b.double2().y; + return r_val; + } +#endif template KOKKOS_FORCEINLINE_FUNCTION @@ -449,6 +472,18 @@ namespace KokkosBatched { r_val[i] = a[i] * b[i]; return r_val; } + +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) + operator * (const Vector,2> &a, const Vector,2> &b) { + double2 r_val; + r_val.x = a.double2().x * b.double2().x; + r_val.y = a.double2().y * b.double2().y; + return r_val; + } +#endif template KOKKOS_FORCEINLINE_FUNCTION @@ -689,6 +724,17 @@ namespace KokkosBatched { return r_val; } +#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) + operator / (const Vector,2> &a, const Vector,2> &b) { + double2 r_val; + r_val.x = a.double2().x / b.double2().x; + r_val.y = a.double2().y / b.double2().y; + return r_val; + } +#endif template KOKKOS_FORCEINLINE_FUNCTION diff --git a/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp b/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp index c62c7ca7d7..1f871086d4 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp @@ -11,7 +11,7 @@ namespace KokkosBatched { #define KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) typename std::enable_if::value && std::is_integral< T1 >::value,const Vector,l> >::type template - inline + KOKKOS_INLINE_FUNCTION static typename std::enable_if::value,const Vector,l> >::type operator!(const Vector,l> &a) { @@ -28,7 +28,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const Vector,l> &a, const Vector,l> &b) { @@ -45,7 +45,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const Vector,l> &a, const Vector,l> &b) { @@ -62,7 +62,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const Vector,l> &a, const T1 &b) { @@ -79,7 +79,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const Vector,l> &a, const T1 &b) { @@ -96,7 +96,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const T0 &a, const Vector,l> &b) { @@ -113,7 +113,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const T0 &a, const Vector,l> &b) { diff --git a/src/batched/KokkosBatched_Vector_SIMD_Math.hpp b/src/batched/KokkosBatched_Vector_SIMD_Math.hpp index 6e2c387259..7ec9b00302 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Math.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Math.hpp @@ -15,7 +15,7 @@ namespace KokkosBatched { /// simd template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) sqrt(const Vector,l> &a) { @@ -34,7 +34,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) cbrt(const Vector,l> &a) { @@ -53,7 +53,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) log(const Vector,l> &a) { @@ -72,7 +72,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) log10(const Vector,l> &a) { @@ -91,7 +91,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) exp(const Vector,l> &a) { @@ -110,7 +110,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const Vector,l> &a, const Vector,l> &b) { @@ -129,7 +129,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const T0 &a, const Vector,l> &b) { @@ -137,7 +137,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const Vector,l> &a, const T1 &b) { @@ -145,7 +145,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) sin(const Vector,l> &a) { @@ -164,7 +164,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) cos(const Vector,l> &a) { @@ -183,7 +183,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) tan(const Vector,l> &a) { @@ -202,7 +202,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) sinh(const Vector,l> &a) { @@ -221,7 +221,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) cosh(const Vector,l> &a) { @@ -240,7 +240,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) tanh(const Vector,l> &a) { @@ -259,7 +259,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) asin(const Vector,l> &a) { @@ -278,7 +278,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) acos(const Vector,l> &a) { @@ -297,7 +297,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan(const Vector,l> &a) { @@ -316,7 +316,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const Vector,l> &a, const Vector,l> &b) { @@ -335,7 +335,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const T &a, const Vector,l> &b) { @@ -343,7 +343,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const Vector,l> &a, const T &b) { diff --git a/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp b/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp index 62e4af043b..ca11d30391 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp @@ -38,7 +38,7 @@ namespace KokkosBatched { // vector, scalar template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, @@ -51,7 +51,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, @@ -65,7 +65,7 @@ namespace KokkosBatched { // scalar, vector template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, @@ -78,7 +78,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, @@ -92,7 +92,7 @@ namespace KokkosBatched { // vector, vector template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, @@ -105,7 +105,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, @@ -117,7 +117,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T reduce(const Vector,l> &val, const BinaryOp &func) { @@ -128,7 +128,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T reduce(const Vector,l> &val, const BinaryOp &func, const T init) { @@ -139,7 +139,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static bool is_all_true(const Vector,l> &cond) { @@ -149,7 +149,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static bool is_any_true(const Vector,l> &cond) { @@ -159,7 +159,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T min(const Vector,l> &val) { @@ -169,7 +169,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T max(const Vector,l> &val) { @@ -179,7 +179,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T sum(const Vector,l> &val) { @@ -189,7 +189,7 @@ namespace KokkosBatched { } template - inline + KOKKOS_INLINE_FUNCTION static T prod(const Vector,l> &val) { diff --git a/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp b/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp index 511135e7d8..f5796dc115 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp @@ -13,7 +13,7 @@ namespace KokkosBatched { #undef KOKKOSBATCHED_RELATION_OPERATOR #define KOKKOSBATCHED_RELATION_OPERATOR(op) \ template \ - inline \ + KOKKOS_INLINE_FUNCTION \ const Vector,l> operator op (const Vector,l> &a, const Vector,l> &b) { \ Vector,l> r_val; \ for (int i=0;i \ - inline \ + KOKKOS_INLINE_FUNCTION \ const Vector,l> operator op (const Vector,l> &a, const T2 &b) { \ Vector,l> r_val; \ for (int i=0;i \ - inline \ + KOKKOS_INLINE_FUNCTION \ const Vector,l> operator op (const T1 &a, const Vector,l> &b) { \ Vector,l> r_val; \ for (int i=0;i Date: Thu, 7 Feb 2019 15:38:38 -0700 Subject: [PATCH 107/190] KokkosBlas - print statement is guarded by the KOKKOSKERNELS_ENABLE_TPL_BLAS this is problematic when cuda is enalbed and the function cannot see the print function. --- CMakeLists.txt | 29 ++++++++++++------- .../tpls/KokkosBlas1_axpby_tpl_spec_decl.hpp | 9 ++++-- .../tpls/KokkosBlas1_dot_tpl_spec_decl.hpp | 14 ++++++--- .../tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp | 12 ++++++-- .../tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp | 12 ++++++-- .../tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp | 12 ++++++-- .../tpls/KokkosBlas1_scal_tpl_spec_decl.hpp | 13 +++++---- 7 files changed, 70 insertions(+), 31 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ef6b2a782b..4715d11a73 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -290,23 +290,30 @@ ENDIF() # Enable Third Party Libraries # ================================================================== -IF (TPL_ENABLE_BLAS) - SET(KOKKOSKERNELS_ENABLE_TPL_BLAS ${TPL_ENABLE_BLAS}) +# user overriding kokkoskernels +IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_BLAS) + IF (TPL_ENABLE_BLAS) + SET(KOKKOSKERNELS_ENABLE_TPL_BLAS ${TPL_ENABLE_BLAS}) + ENDIF() ENDIF() -IF (TPL_ENABLE_MKL) - SET(KOKKOSKERNELS_ENABLE_TPL_MKL ${TPL_ENABLE_MKL}) + +IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_MKL) + IF (TPL_ENABLE_MKL) + SET(KOKKOSKERNELS_ENABLE_TPL_MKL ${TPL_ENABLE_MKL}) + ENDIF() ENDIF() IF(${Kokkos_ENABLE_Cuda}) - IF (NOT KOKKOSKERNELS_ENABLE_TPL_BLAS) - SET(KOKKOSKERNELS_ENABLE_TPL_BLAS ON) - LIST(APPEND TPL_LIST "BLAS") - ENDIF() # CUBLAS is ON by default when CUDA is enabled - SET(KOKKOSKERNELS_ENABLE_TPL_CUBLAS ON) + IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_CUBLAS) + SET(KOKKOSKERNELS_ENABLE_TPL_CUBLAS ON) + ENDIF() + # Tribit provides TPL mechanism for CUSPARSE; thus, use it - IF (TPL_ENABLE_CUSPARSE) - SET(KOKKOSKERNELS_ENABLE_TPL_CUSPARSE ${TPL_ENABLE_CUSPARSE}) + IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_CUSPARSE) + IF (TPL_ENABLE_CUSPARSE) + SET(KOKKOSKERNELS_ENABLE_TPL_CUSPARSE ${TPL_ENABLE_CUSPARSE}) + ENDIF() ENDIF() ENDIF() diff --git a/src/impl/tpls/KokkosBlas1_axpby_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_axpby_tpl_spec_decl.hpp index 548ede0273..035c8b3144 100644 --- a/src/impl/tpls/KokkosBlas1_axpby_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_axpby_tpl_spec_decl.hpp @@ -45,8 +45,6 @@ #define KOKKOSBLAS1_AXPBY_TPL_SPEC_DECL_HPP_ -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" namespace KokkosBlas { namespace Impl { @@ -59,6 +57,13 @@ namespace { #endif } } +} +} + +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" +namespace KokkosBlas { +namespace Impl { #define KOKKOSBLAS1_DAXPBY_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ diff --git a/src/impl/tpls/KokkosBlas1_dot_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_dot_tpl_spec_decl.hpp index 4d23c0094d..402b203438 100644 --- a/src/impl/tpls/KokkosBlas1_dot_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_dot_tpl_spec_decl.hpp @@ -44,14 +44,10 @@ #ifndef KOKKOSBLAS1_DOT_TPL_SPEC_DECL_HPP_ #define KOKKOSBLAS1_DOT_TPL_SPEC_DECL_HPP_ -// Generic Host side BLAS (could be MKL or whatever) -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" namespace KokkosBlas { namespace Impl { - namespace { template inline void dot_print_specialization() { @@ -61,6 +57,16 @@ namespace { } } +} +} + +// Generic Host side BLAS (could be MKL or whatever) +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" + +namespace KokkosBlas { +namespace Impl { + #define KOKKOSBLAS1_DDOT_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ struct Dot< \ diff --git a/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp index eb88f90355..a6b42d5f51 100644 --- a/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp @@ -44,9 +44,6 @@ #ifndef KOKKOSBLAS1_NRM1_TPL_SPEC_DECL_HPP_ #define KOKKOSBLAS1_NRM1_TPL_SPEC_DECL_HPP_ -// Generic Host side BLAS (could be MKL or whatever) -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" namespace KokkosBlas { namespace Impl { @@ -60,6 +57,15 @@ namespace { #endif } } +} +} + +namespace KokkosBlas { +namespace Impl { + +// Generic Host side BLAS (could be MKL or whatever) +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" #define KOKKOSBLAS1_DNRM1_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ diff --git a/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp index d0040839da..5899d2f18b 100644 --- a/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp @@ -44,9 +44,6 @@ #ifndef KOKKOSBLAS1_NRM2_TPL_SPEC_DECL_HPP_ #define KOKKOSBLAS1_NRM2_TPL_SPEC_DECL_HPP_ -// Generic Host side BLAS (could be MKL or whatever) -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" namespace KokkosBlas { namespace Impl { @@ -60,6 +57,15 @@ namespace { #endif } } +} +} + +namespace KokkosBlas { +namespace Impl { + +// Generic Host side BLAS (could be MKL or whatever) +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" #define KOKKOSBLAS1_DNRM2_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ diff --git a/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp index 485830ec1f..152e026718 100644 --- a/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp @@ -44,9 +44,6 @@ #ifndef KOKKOSBLAS1_NRMINF_TPL_SPEC_DECL_HPP_ #define KOKKOSBLAS1_NRMINF_TPL_SPEC_DECL_HPP_ -// Generic Host side BLAS (could be MKL or whatever) -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" namespace KokkosBlas { namespace Impl { @@ -60,6 +57,15 @@ namespace { #endif } } +} +} + +namespace KokkosBlas { +namespace Impl { + +// Generic Host side BLAS (could be MKL or whatever) +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" #define KOKKOSBLAS1_DNRMINF_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ diff --git a/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp index 8061ef0dd3..c3b5096ca5 100644 --- a/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp @@ -44,14 +44,9 @@ #ifndef KOKKOSBLAS1_SCAL_TPL_SPEC_DECL_HPP_ #define KOKKOSBLAS1_SCAL_TPL_SPEC_DECL_HPP_ -// Generic Host side BLAS (could be MKL or whatever) -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" - namespace KokkosBlas { namespace Impl { - namespace { template inline void scal_print_specialization() { @@ -60,6 +55,14 @@ namespace { #endif } } +} +} + +namespace KokkosBlas { +namespace Impl { + +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" #define KOKKOSBLAS1_DSCAL_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ From 01588ae0fea07e17100753d56b8a95f7c89a88f2 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 7 Feb 2019 17:06:52 -0700 Subject: [PATCH 108/190] KokkosBlas - fix the wrong ifdef locations --- scripts/test_all_sandia | 1 + src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp | 6 +++--- src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp | 8 +++++--- src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp | 7 ++++--- src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp | 5 +++-- 5 files changed, 16 insertions(+), 11 deletions(-) diff --git a/scripts/test_all_sandia b/scripts/test_all_sandia index d723e68a52..d9eca20f4f 100755 --- a/scripts/test_all_sandia +++ b/scripts/test_all_sandia @@ -260,6 +260,7 @@ elif [ "$MACHINE" = "white" ]; then "gcc/7.2.0 $BASE_MODULE_LIST $IBM_BUILD_LIST g++ $GCC_WARNING_FLAGS" "ibm/16.1.0 $IBM_MODULE_LIST "Serial" xlC $IBM_WARNING_FLAGS" "cuda/9.2.88 $CUDA_MODULE_LIST "Cuda_OpenMP" ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" + "cuda/10.0.130 $CUDA10_MODULE_LIST "Cuda_Serial" ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" ) else # Format: (compiler module-list build-list exe-name warning-flag) diff --git a/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp index a6b42d5f51..548f0025e3 100644 --- a/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrm1_tpl_spec_decl.hpp @@ -60,13 +60,13 @@ namespace { } } -namespace KokkosBlas { -namespace Impl { - // Generic Host side BLAS (could be MKL or whatever) #ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS #include "KokkosBlas_Host_tpl.hpp" +namespace KokkosBlas { +namespace Impl { + #define KOKKOSBLAS1_DNRM1_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ struct Nrm1< \ diff --git a/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp index 5899d2f18b..f90a05aca7 100644 --- a/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrm2_tpl_spec_decl.hpp @@ -60,13 +60,14 @@ namespace { } } -namespace KokkosBlas { -namespace Impl { - // Generic Host side BLAS (could be MKL or whatever) #ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS #include "KokkosBlas_Host_tpl.hpp" +namespace KokkosBlas { +namespace Impl { + + #define KOKKOSBLAS1_DNRM2_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ struct Nrm2< \ @@ -368,4 +369,5 @@ KOKKOSBLAS1_CNRM2_TPL_SPEC_DECL_CUBLAS( Kokkos::LayoutLeft, Kokkos::CudaSpace, f #endif + #endif diff --git a/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp index 152e026718..f9e61422e2 100644 --- a/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_nrminf_tpl_spec_decl.hpp @@ -60,13 +60,14 @@ namespace { } } -namespace KokkosBlas { -namespace Impl { - // Generic Host side BLAS (could be MKL or whatever) #ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS #include "KokkosBlas_Host_tpl.hpp" +namespace KokkosBlas { +namespace Impl { + + #define KOKKOSBLAS1_DNRMINF_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ struct NrmInf< \ diff --git a/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp index c3b5096ca5..58fa48b717 100644 --- a/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas1_scal_tpl_spec_decl.hpp @@ -58,11 +58,12 @@ namespace { } } +#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS +#include "KokkosBlas_Host_tpl.hpp" + namespace KokkosBlas { namespace Impl { -#ifdef KOKKOSKERNELS_ENABLE_TPL_BLAS -#include "KokkosBlas_Host_tpl.hpp" #define KOKKOSBLAS1_DSCAL_TPL_SPEC_DECL_BLAS( LAYOUT, MEMSPACE, ETI_SPEC_AVAIL ) \ template \ From cc7dedc0adb428264ffdb31b7cbc03eb14d96bf4 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 7 Feb 2019 17:26:46 -0700 Subject: [PATCH 109/190] KokkosKernels - cmake tpl overriding check TPL_ENABLE_BLAH.... --- CMakeLists.txt | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4715d11a73..26cd2ca2cc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -290,14 +290,30 @@ ENDIF() # Enable Third Party Libraries # ================================================================== -# user overriding kokkoskernels -IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_BLAS) +IF (DEFINED KOKKOSKERNELS_ENABLE_TPL_BLAS) + # user overriding kokkoskernels + IF (KOKKOSKERNELS_ENABLE_TPL_BLAS) + IF (NOT TPL_ENABLE_BLAS) + MESSAGE( WARNING "KOKKOSKERNELS_ENABLE_TPL_BLAS is ON but TPL_ENABLE_BLAS is OFF. Please set TPL_ENABLE_BLAS:BOOL=ON") + SET(KOKKOSKERNELS_ENABLE_TPL_BLAS OFF) + ENDIF() + ENDIF() +ELSE() + # default behavior IF (TPL_ENABLE_BLAS) SET(KOKKOSKERNELS_ENABLE_TPL_BLAS ${TPL_ENABLE_BLAS}) ENDIF() ENDIF() -IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_MKL) +IF (DEFINED KOKKOSKERNELS_ENABLE_TPL_MKL) + # user overriding kokkoskernels + IF (KOKKOSKERNELS_ENABLE_TPL_MKL) + IF (NOT TPL_ENABLE_MKL) + MESSAGE( WARNING "KOKKOSKERNELS_ENABLE_TPL_MKL is ON but TPL_ENABLE_MKL is OFF. Please set TPL_ENABLE_MKL:BOOL=ON") + SET(KOKKOSKERNELS_ENABLE_TPL_MKL OFF) + ENDIF() + ENDIF() +ELSE() IF (TPL_ENABLE_MKL) SET(KOKKOSKERNELS_ENABLE_TPL_MKL ${TPL_ENABLE_MKL}) ENDIF() @@ -310,7 +326,12 @@ IF(${Kokkos_ENABLE_Cuda}) ENDIF() # Tribit provides TPL mechanism for CUSPARSE; thus, use it - IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_CUSPARSE) + IF (DEFINED KOKKOSKERNELS_ENABLE_TPL_CUSPARSE) + IF (NOT TPL_ENABLE_CUSPARSE) + MESSAGE( WARNING "KOKKOSKERNELS_ENABLE_TPL_CUSPARSE is ON but TPL_ENABLE_CUSPARSE is OFF. Please set TPL_ENABLE_CUSPARSE:BOOL=ON") + SET(KOKKOSKERNELS_ENABLE_TPL_CUSPARSE OFF) + ENDIF() + ELSE() IF (TPL_ENABLE_CUSPARSE) SET(KOKKOSKERNELS_ENABLE_TPL_CUSPARSE ${TPL_ENABLE_CUSPARSE}) ENDIF() From 293962a27f6bde74a179820c7b3d82fc6dc02e04 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Tue, 12 Feb 2019 17:03:41 -0700 Subject: [PATCH 110/190] KokkosBatched - add a more selective interface --- src/batched/KokkosBatched_Gemm_Decl.hpp | 35 ++++++++- src/batched/KokkosBatched_Gemv_Decl.hpp | 71 ++++++++++++++---- src/batched/KokkosBatched_LU_Decl.hpp | 23 ++++++ src/batched/KokkosBatched_Trsm_Decl.hpp | 29 ++++++++ src/batched/KokkosBatched_Trsv_Decl.hpp | 96 ++++++++++++++++++++----- src/batched/KokkosBatched_Util.hpp | 11 ++- 6 files changed, 228 insertions(+), 37 deletions(-) diff --git a/src/batched/KokkosBatched_Gemm_Decl.hpp b/src/batched/KokkosBatched_Gemm_Decl.hpp index 937c5ff76f..cd5f1bd302 100644 --- a/src/batched/KokkosBatched_Gemm_Decl.hpp +++ b/src/batched/KokkosBatched_Gemm_Decl.hpp @@ -50,9 +50,38 @@ namespace KokkosBatched { const ScalarType beta, const CViewType &C); }; - - // specialized for different m and n - // C(mxn) += alpha * A(mxk) B(kxn) + + + /// + /// Selective Interface + /// + template + struct Gemm { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialGemm::invoke(alpha, A, B, beta, C); + } else if (std::is_same::value) { + r_val = TeamGemm::invoke(member, alpha, A, B, beta, C); + } + return r_val; + } + }; } } diff --git a/src/batched/KokkosBatched_Gemv_Decl.hpp b/src/batched/KokkosBatched_Gemv_Decl.hpp index 0d276351d0..ed910469dc 100644 --- a/src/batched/KokkosBatched_Gemv_Decl.hpp +++ b/src/batched/KokkosBatched_Gemv_Decl.hpp @@ -28,14 +28,6 @@ namespace KokkosBatched { const yViewType &y); }; -#define KOKKOSBATCHED_SERIAL_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::SerialGemvInternal \ - ::invoke(M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) - -#define KOKKOSBATCHED_SERIAL_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::SerialGemvInternal \ - ::invoke(N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) - /// /// Team Gemv /// @@ -58,15 +50,66 @@ namespace KokkosBatched { const yViewType &y); }; + /// + /// Selective Interface + /// + template + struct Gemv { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialGemv::invoke(alpha, A, x, beta, y); + } else if (std::is_same::value) { + r_val = TeamGemv::invoke(member, alpha, A, x, beta, y); + } + return r_val; + } + }; + +} +} + +#define KOKKOSBATCHED_SERIAL_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ + KokkosBatched::Experimental::SerialGemvInternal \ + ::invoke(M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) + +#define KOKKOSBATCHED_SERIAL_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ + KokkosBatched::Experimental::SerialGemvInternal \ + ::invoke(N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) + #define KOKKOSBATCHED_TEAM_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::TeamGemvInternal \ - ::invoke(MEMBER, M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) - + KokkosBatched::Experimental::TeamGemvInternal \ + ::invoke(MEMBER, M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) + #define KOKKOSBATCHED_TEAM_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::TeamGemvInternal \ - ::invoke(MEMBER, N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) + KokkosBatched::Experimental::TeamGemvInternal \ + ::invoke(MEMBER, N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) + +#define KOKKOSBATCHED_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ + } +#define KOKKOSBATCHED_GEMV_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ } -} #endif diff --git a/src/batched/KokkosBatched_LU_Decl.hpp b/src/batched/KokkosBatched_LU_Decl.hpp index 2475677883..3ffcedde36 100644 --- a/src/batched/KokkosBatched_LU_Decl.hpp +++ b/src/batched/KokkosBatched_LU_Decl.hpp @@ -30,6 +30,29 @@ namespace KokkosBatched { const AViewType &A, const typename MagnitudeScalarType::type tiny = 0); }; + + /// + /// Selective Interface + /// + template + struct LU { + // no piv version + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialLU::invoke(A, tiny); + } else if (std::is_same::value) { + r_val = TeamLU::invoke(member, A, tiny); + } + return r_val; + } + }; } } diff --git a/src/batched/KokkosBatched_Trsm_Decl.hpp b/src/batched/KokkosBatched_Trsm_Decl.hpp index 354adcffbf..dce98acac4 100644 --- a/src/batched/KokkosBatched_Trsm_Decl.hpp +++ b/src/batched/KokkosBatched_Trsm_Decl.hpp @@ -42,6 +42,35 @@ namespace KokkosBatched { const BViewType &B); }; + /// + /// Selective Interface + /// + template + struct Trsm { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialTrsm::invoke(alpha, A, B); + } else if (std::is_same::value) { + r_val = TeamTrsm::invoke(member, alpha, A, B); + } + return r_val; + } + }; + } } diff --git a/src/batched/KokkosBatched_Trsv_Decl.hpp b/src/batched/KokkosBatched_Trsv_Decl.hpp index 0c2c194a3e..f7d5391921 100644 --- a/src/batched/KokkosBatched_Trsv_Decl.hpp +++ b/src/batched/KokkosBatched_Trsv_Decl.hpp @@ -27,17 +27,6 @@ namespace KokkosBatched { const bViewType &b); }; -#define KOKKOSBATCHED_SERIAL_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) - -#define KOKKOSBATCHED_SERIAL_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) - -#define KOKKOSBATCHED_SERIAL_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) - -#define KOKKOSBATCHED_SERIAL_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) /// /// Team Trsv @@ -61,19 +50,88 @@ namespace KokkosBatched { const bViewType &b); }; + + /// + /// Selective Interface + /// + template + struct Trsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialTrsv::invoke(alpha, A, b); + } else if (std::is_same::value) { + r_val = TeamTrsv::invoke(member, alpha, A, b); + } + return r_val; + } + }; + + } +} + +#define KOKKOSBATCHED_SERIAL_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + +#define KOKKOSBATCHED_SERIAL_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + +#define KOKKOSBATCHED_SERIAL_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + +#define KOKKOSBATCHED_SERIAL_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + #define KOKKOSBATCHED_TEAM_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) - + KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + #define KOKKOSBATCHED_TEAM_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) - + KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + #define KOKKOSBATCHED_TEAM_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) - + KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + #define KOKKOSBATCHED_TEAM_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + +#define KOKKOSBATCHED_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } +#define KOKKOSBATCHED_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } + +#define KOKKOSBATCHED_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } + +#define KOKKOSBATCHED_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ } -} #endif diff --git a/src/batched/KokkosBatched_Util.hpp b/src/batched/KokkosBatched_Util.hpp index bf28ac87fa..0c6bd67dba 100644 --- a/src/batched/KokkosBatched_Util.hpp +++ b/src/batched/KokkosBatched_Util.hpp @@ -240,7 +240,16 @@ namespace KokkosBatched { struct NonUnit { static const bool use_unit_diag = false; }; }; - struct Algo { + struct Mode { + struct Serial { + static const char *name() { return "Serial"; } + }; + struct Team { + static const char *name() { return "Team"; } + }; + }; + + struct Algo { struct Level3 { struct Unblocked { static const char* name() { return "Unblocked"; } From 5d051210b4e1391a1238121ccbfc76f8c07ab286 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 14:17:52 -0700 Subject: [PATCH 111/190] KokkosBatched - remove warnings --- .../KokkosBatched_Eigendecomposition_Serial_Internal.hpp | 2 +- .../KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp | 2 +- src/batched/KokkosBatched_Schur_Serial_Internal.hpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index 807718c69f..93a13e62f8 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -58,7 +58,7 @@ namespace KokkosBatched { typedef Kokkos::Details::ArithTraits ats; const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); - const Kokkos::pair identity(one, zero); + //const Kokkos::pair identity(one, zero); /// step 0: input checking assert( (wlen >= (2*m*m+5*m)) && "Eigendecomposition: workspace size is too small"); diff --git a/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp b/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp index fbab3d346c..8b679142d5 100644 --- a/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp @@ -43,7 +43,7 @@ namespace KokkosBatched { typedef Kokkos::complex complex_type; const value_type zero(0), one(1); - const int ss(ss0+ss1); + //const int ss(ss0+ss1); /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); value_type *b = w; // consider complex case diff --git a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp index e1060d90f1..a4a4aadbf0 100644 --- a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp @@ -59,7 +59,7 @@ namespace KokkosBatched { const int user_max_iteration = -1) { typedef RealType real_type; typedef Kokkos::Details::ArithTraits ats; - const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); + const real_type /* one(1), */zero(0), tol = 1e2*ats::epsilon(); const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; if (wlen < m*5) Kokkos::abort("Error: provided workspace is smaller than 3*m"); From 1ce948111f7f120a392d5ddd0461095ea17c7cb3 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 15:09:55 -0700 Subject: [PATCH 112/190] KokkosBatched - fix interface of inverse lu and solve lu when transpose flag is on, solve lu computes wrong. as solve lu and inverse lu uses other batched rouotines, the top level interface (decl) suffices. --- src/batched/KokkosBatched_InverseLU_Decl.hpp | 18 ++- .../KokkosBatched_InverseLU_Serial_Impl.hpp | 84 ------------ .../KokkosBatched_InverseLU_Team_Impl.hpp | 100 -------------- src/batched/KokkosBatched_SolveLU_Decl.hpp | 69 +++++++++- .../KokkosBatched_SolveLU_Serial_Impl.hpp | 128 ------------------ .../KokkosBatched_SolveLU_Team_Impl.hpp | 128 ------------------ 6 files changed, 77 insertions(+), 450 deletions(-) delete mode 100644 src/batched/KokkosBatched_InverseLU_Team_Impl.hpp delete mode 100644 src/batched/KokkosBatched_SolveLU_Serial_Impl.hpp delete mode 100644 src/batched/KokkosBatched_SolveLU_Team_Impl.hpp diff --git a/src/batched/KokkosBatched_InverseLU_Decl.hpp b/src/batched/KokkosBatched_InverseLU_Decl.hpp index e7652ea445..3b9e4cbc7c 100644 --- a/src/batched/KokkosBatched_InverseLU_Decl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Decl.hpp @@ -5,32 +5,42 @@ /// \author Vinh Dang (vqdang@sandia.gov) #include "KokkosBatched_Vector.hpp" +#include "KokkosBatched_Copy_Decl.hpp" +#include "KokkosBatched_Copy_Impl.hpp" +#include "KokkosBatched_SetIdentity_Decl.hpp" +#include "KokkosBatched_SetIdentity_Impl.hpp" namespace KokkosBatched { namespace Experimental { template struct SerialInverseLU { - // no piv version template KOKKOS_INLINE_FUNCTION static int invoke(const AViewType &A, - const WViewType &W); + const WViewType &W) { + SerialCopy::invoke(A, W); + SerialSetIdentity::invoke(A); + SerialSolveLU::invoke(A,B); + } }; template struct TeamInverseLU { - // no piv version template KOKKOS_INLINE_FUNCTION static int invoke(const MemberType &member, const AViewType &A, - const WViewType &W); + const WViewType &W) { + TeamCopy::invoke(A, W); + TeamSetIdentity::invoke(A); + TeamSolveLU::invoke(A,B); + } }; } diff --git a/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp b/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp index 8a815de407..b2ad7bedb3 100644 --- a/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp @@ -68,90 +68,6 @@ namespace KokkosBatched { } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialInverseLU:: - invoke(const AViewType &A, - const WViewType &W) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert(WViewType::rank == 1, "W should have one dimension"); - static_assert(std::is_same::value, "A and W should be on the same memory space"); - static_assert(!std::is_same::value, "W should be an contiguous 1D array"); - assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); - assert(A.extent(0)==A.extent(1)); - - typedef typename AViewType::value_type ScalarType; - - auto B = Kokkos::View >(W.data(), A.extent(0), A.extent(1)); - - const ScalarType one(1.0); - -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (size_t i=0;i::invoke(A,B); - -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (size_t i=0;i - template - KOKKOS_INLINE_FUNCTION - int - SerialInverseLU:: - invoke(const AViewType &A, - const WViewType &W) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert(WViewType::rank == 1, "W should have one dimension"); - static_assert(std::is_same::value, "A and W should be on the same memory space"); - static_assert(!std::is_same::value, "W should be an contiguous 1D array"); - assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); - assert(A.extent(0)==A.extent(1)); - - typedef typename AViewType::value_type ScalarType; - - auto B = Kokkos::View >(W.data(), A.extent(0), A.extent(1)); - - const ScalarType one(1.0); - -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (size_t i=0;i::invoke(A,B); - -#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) -#pragma unroll -#endif - for (size_t i=0;i - struct TeamInverseLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const WViewType &W) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert(WViewType::rank == 1, "W should have one dimension"); - static_assert(std::is_same::value, "A and W should be on the same memory space"); - static_assert(!std::is_same::value, "W should be an contiguous 1D array"); - assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); - assert(A.extent(0)==A.extent(1)); - - typedef typename AViewType::value_type ScalarType; - - auto B = Kokkos::View >(W.data(), A.extent(0), A.extent(1)); - - const ScalarType one(1.0); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,A.extent(1)),[&](const int &i) { - B(i,i) = one; - }); - - //First, compute L inverse by solving the system L*Linv = I for Linv - //Second, compute A inverse by solving the system U*Ainv = Linv for Ainv - TeamSolveLU::invoke(member, A, B); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,A.extent(0)*A.extent(1)),[&](const int &tid) { - int i = tid/A.extent(1); - int j = tid%A.extent(1); - A(i,j) = B(i,j); - }); - - return 0; - } - }; - - template - struct TeamInverseLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const WViewType &W) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert(WViewType::rank == 1, "W should have one dimension"); - static_assert(std::is_same::value, "A and W should be on the same memory space"); - static_assert(!std::is_same::value, "W should be an contiguous 1D array"); - assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); - assert(A.extent(0)==A.extent(1)); - - typedef typename AViewType::value_type ScalarType; - - auto B = Kokkos::View >(W.data(), A.extent(0), A.extent(1)); - - const ScalarType one(1.0); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,A.extent(1)),[&](const int &i) { - B(i,i) = one; - }); - - //First, compute L inverse by solving the system L*Linv = I for Linv - //Second, compute A inverse by solving the system U*Ainv = Linv for Ainv - TeamSolveLU::invoke(member, A, B); - - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,A.extent(0)*A.extent(1)),[&](const int &tid) { - int i = tid/A.extent(1); - int j = tid%A.extent(1); - A(i,j) = B(i,j); - }); - - return 0; - } - }; - - } -} - -#endif diff --git a/src/batched/KokkosBatched_SolveLU_Decl.hpp b/src/batched/KokkosBatched_SolveLU_Decl.hpp index 9c8b71a58d..400b45fd59 100644 --- a/src/batched/KokkosBatched_SolveLU_Decl.hpp +++ b/src/batched/KokkosBatched_SolveLU_Decl.hpp @@ -5,12 +5,15 @@ /// \author Vinh Dang (vqdang@sandia.gov) #include "KokkosBatched_Vector.hpp" +#include "KokkosBatched_Trsm_Decl.hpp" +#include "KokkosBatched_Trsm_Serial_Impl.hpp" +#include "KokkosBatched_Trsm_Team_Impl.hpp" namespace KokkosBatched { namespace Experimental { - template + template struct SerialSolveLU { // no piv version template::value) { + //First, compute Y (= U*X) by solving the system L*Y = B for Y + SerialTrsm::invoke(one, A, B); + //Second, compute X by solving the system U*X = Y for X + SerialTrsm::invoke(one, A, B); + } else if (std::is_same::value || + std::is_same::value) { + //First, compute Y (= L'*X) by solving the system U'*Y = B for Y + SerialTrsm::invoke(one, A, B); + //Second, compute X by solving the system L'*X = Y for X + SerialTrsm::invoke(one, A, B); + } + } }; template + typename ArgTrans, + typename ArgAlgo> struct TeamSolveLU { // no piv version template::value) { + //First, compute Y (= U*X) by solving the system L*Y = B for Y + TeamTrsm::invoke(member, one, A, B); + //Second, compute X by solving the system U*X = Y for X + TeamTrsm::invoke(member, one, A, B); + } else if (std::is_same::value || + std::is_same::value) { + //First, compute Y (= L'*X) by solving the system U'*Y = B for Y + TeamTrsm::invoke(member, one, A, B); + //Second, compute X by solving the system L'*X = Y for X + TeamTrsm::invoke(member, one, A, B); + } + } }; + + /// + /// Selective Interface + /// + template + struct SolveLU { + // no piv version + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialSolveLU::invoke(A, B); + } else if (std::is_same::value) { + r_val = TeamLU::invoke(member, A, B); + } + return r_val; + } + }; + } } diff --git a/src/batched/KokkosBatched_SolveLU_Serial_Impl.hpp b/src/batched/KokkosBatched_SolveLU_Serial_Impl.hpp deleted file mode 100644 index 1a5e18c369..0000000000 --- a/src/batched/KokkosBatched_SolveLU_Serial_Impl.hpp +++ /dev/null @@ -1,128 +0,0 @@ -#ifndef __KOKKOSBATCHED_SOLVELU_SERIAL_IMPL_HPP__ -#define __KOKKOSBATCHED_SOLVELU_SERIAL_IMPL_HPP__ - - -/// \author Vinh Dang (vqdang@sandia.gov) - -#include "KokkosBatched_Util.hpp" -#include "KokkosBatched_Trsm_Decl.hpp" -#include "KokkosBatched_Trsm_Serial_Impl.hpp" - -namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// ========= - - /// - /// SolveLU no piv - /// - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialSolveLU:: - invoke(const AViewType &A, - const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= U*X) by solving the system L*Y = B for Y - SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system U*X = Y for X - SerialTrsm::invoke(one, A, B); - - return 0; - } - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialSolveLU:: - invoke(const AViewType &A, - const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= U*X) by solving the system L*Y = B for Y - SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system U*X = Y for X - SerialTrsm::invoke(one, A, B); - - return 0; - } - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialSolveLU:: - invoke(const AViewType &A, - const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system L'*X = Y for X - SerialTrsm::invoke(one, A, B); - - return 0; - } - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialSolveLU:: - invoke(const AViewType &A, - const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system L'*X = Y for X - SerialTrsm::invoke(one, A, B); - - return 0; - } - - } -} - -#endif diff --git a/src/batched/KokkosBatched_SolveLU_Team_Impl.hpp b/src/batched/KokkosBatched_SolveLU_Team_Impl.hpp deleted file mode 100644 index 061f2bcce5..0000000000 --- a/src/batched/KokkosBatched_SolveLU_Team_Impl.hpp +++ /dev/null @@ -1,128 +0,0 @@ -#ifndef __KOKKOSBATCHED_SOLVELU_TEAM_IMPL_HPP__ -#define __KOKKOSBATCHED_SOLVELU_TEAM_IMPL_HPP__ - - -/// \author Vinh Dang (vqdang@sandia.gov) - -#include "KokkosBatched_Util.hpp" -#include "KokkosBatched_Trsm_Decl.hpp" -#include "KokkosBatched_Trsm_Team_Impl.hpp" - -namespace KokkosBatched { - namespace Experimental { - /// - /// Team Impl - /// ========= - - /// - /// SolveLU no piv - /// - - template - struct TeamSolveLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= U*X) by solving the system L*Y = B for Y - TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system U*X = Y for X - TeamTrsm::invoke(member, one, A, B); - - return 0; - } - }; - - template - struct TeamSolveLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= U*X) by solving the system L*Y = B for Y - TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system U*X = Y for X - TeamTrsm::invoke(member, one, A, B); - - return 0; - } - }; - - template - struct TeamSolveLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system L'*X = Y for X - TeamTrsm::invoke(member, one, A, B); - - return 0; - } - }; - - template - struct TeamSolveLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, const BViewType &B) { - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert((BViewType::rank == 1)||(BViewType::rank == 2), "B should have either one dimension or two dimensions"); - static_assert(std::is_same::value, "A and B should be on the same memory space"); - assert(A.extent(0)==A.extent(1)); - assert(A.extent(1)==B.extent(0)); - - typedef typename AViewType::value_type ScalarType; - - const ScalarType one(1.0); - - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system L'*X = Y for X - TeamTrsm::invoke(member, one, A, B); - - return 0; - } - }; - - } -} - -#endif From 8bd115332bca8212dd75c1e71bc8713eb81b1cd9 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 15:55:37 -0700 Subject: [PATCH 113/190] KokkosBatched - eigen decomposition compiling test --- ...osBatched_Eigendecomposition_Team_Impl.hpp | 12 +- unit_test/Makefile | 3 + .../Test_Batched_SerialEigendecomposition.hpp | 117 ++++++++++++++++++ ..._Batched_SerialEigendecomposition_Real.hpp | 13 ++ .../batched/Test_Batched_SerialSolveLU.hpp | 4 +- .../batched/Test_Batched_TeamInverseLU.hpp | 2 +- .../batched/Test_Batched_TeamSolveLU.hpp | 4 +- ..._Batched_SerialEigendecomposition_Real.cpp | 3 + ..._Batched_SerialEigendecomposition_Real.cpp | 3 + ..._Batched_SerialEigendecomposition_Real.cpp | 3 + 10 files changed, 148 insertions(+), 16 deletions(-) create mode 100644 unit_test/batched/Test_Batched_SerialEigendecomposition.hpp create mode 100644 unit_test/batched/Test_Batched_SerialEigendecomposition_Real.hpp create mode 100644 unit_test/cuda/Test_Cuda_Batched_SerialEigendecomposition_Real.cpp create mode 100644 unit_test/openmp/Test_OpenMP_Batched_SerialEigendecomposition_Real.cpp create mode 100644 unit_test/serial/Test_Serial_Batched_SerialEigendecomposition_Real.cpp diff --git a/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp index 6ae1752e21..0b5304b7d0 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Team_Impl.hpp @@ -38,17 +38,7 @@ namespace KokkosBatched { assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); - /// static assert A,er,ei,UL,UR,W has the same value_type - /// static assert all views have the same memory space - return TeamEigendecompositionInternal - ::invoke(member, - A.extent(0), - A.data(), A.stride(0), A.stride(1), - er.data(), er.stride(0), - ei.data(), ei.stride(0), - UL.data(), UL.stride(0), UL.stride(1), - UR.data(), UR.stride(0), UR.stride(1), - W.data(), W.extent(0)); + return 0; } }; diff --git a/unit_test/Makefile b/unit_test/Makefile index 62996ffb85..abf54844f6 100644 --- a/unit_test/Makefile +++ b/unit_test/Makefile @@ -145,6 +145,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_OPENMP), 1) OBJ_OPENMP += Test_OpenMP_Batched_TeamInverseLU_Real.o OBJ_OPENMP += Test_OpenMP_Batched_SerialSolveLU_Real.o OBJ_OPENMP += Test_OpenMP_Batched_TeamSolveLU_Real.o + OBJ_OPENMP += Test_OpenMP_Batched_SerialEigendecomposition_Real.o # Complex OBJ_OPENMP += Test_OpenMP_Batched_SerialMatUtil_Complex.o OBJ_OPENMP += Test_OpenMP_Batched_SerialGemm_Complex.o @@ -255,6 +256,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_CUDA), 1) OBJ_CUDA += Test_Cuda_Batched_TeamInverseLU_Real.o OBJ_CUDA += Test_Cuda_Batched_SerialSolveLU_Real.o OBJ_CUDA += Test_Cuda_Batched_TeamSolveLU_Real.o + OBJ_CUDA += Test_Cuda_Batched_SerialEigendecomposition_Real.o # Complex OBJ_CUDA += Test_Cuda_Batched_SerialMatUtil_Complex.o OBJ_CUDA += Test_Cuda_Batched_SerialGemm_Complex.o @@ -360,6 +362,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_SERIAL), 1) OBJ_SERIAL += Test_Serial_Batched_TeamInverseLU_Real.o OBJ_SERIAL += Test_Serial_Batched_SerialSolveLU_Real.o OBJ_SERIAL += Test_Serial_Batched_TeamSolveLU_Real.o + OBJ_SERIAL += Test_Serial_Batched_SerialEigendecomposition_Real.o # Complex OBJ_SERIAL += Test_Serial_Batched_SerialMatUtil_Complex.o OBJ_SERIAL += Test_Serial_Batched_SerialGemm_Complex.o diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp new file mode 100644 index 0000000000..d8a01a98dc --- /dev/null +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp @@ -0,0 +1,117 @@ +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "gtest/gtest.h" +#include "Kokkos_Core.hpp" +#include "Kokkos_Random.hpp" + +//#include "KokkosBatched_Vector.hpp" + +#include "KokkosBatched_Eigendecomposition_Decl.hpp" +#include "KokkosBatched_Eigendecomposition_Serial_Impl.hpp" + +#include "KokkosKernels_TestUtils.hpp" + +using namespace KokkosBatched::Experimental; + +namespace Test { + + template + struct Functor_TestBatchedSerialEigendecomposition { + ViewRank3Type _A; + ViewRank2Type _Er, _Ei; + ViewRank3Type _UL, _UR; + ViewRank2Type _W; + + KOKKOS_INLINE_FUNCTION + Functor_TestBatchedSerialEigendecomposition(const ViewRank3Type A, + const ViewRank2Type Er, + const ViewRank2Type Ei, + const ViewRank3Type UL, + const ViewRank3Type UR, + const ViewRank2Type W) + : _A(A), _Er(Er), _Ei(Ei), _UL(UL), _UR(UR), _W(W) + {} + + KOKKOS_INLINE_FUNCTION + void operator()(const int k) const { + auto A = Kokkos::subview(_A, k, Kokkos::ALL(), Kokkos::ALL()); + auto er = Kokkos::subview(_Er, k, Kokkos::ALL()); + auto ei = Kokkos::subview(_Ei, k, Kokkos::ALL()); + auto UL = Kokkos::subview(_UL, k, Kokkos::ALL(), Kokkos::ALL()); + auto UR = Kokkos::subview(_UR, k, Kokkos::ALL(), Kokkos::ALL()); + auto W = Kokkos::subview(_W, k, Kokkos::ALL()); + + const int r_val = + SerialEigendecomposition::invoke(A, er, ei, UL, UR, W); + } + + inline + void run() { + typedef typename ViewType::value_type value_type; + std::string name_region("KokkosBatched::Test::SerialEigendecomposition"); + std::string name_value_type = ( std::is_same::value ? "::Float" : + std::is_same::value ? "::Double" : + std::is_same >::value ? "::ComplexFloat" : + std::is_same >::value ? "::ComplexDouble" : "::UnknownValueType" ); + std::string name = name_region + name_value_type; + Kokkos::Profiling::pushRegion( name.c_str() ); + Kokkos::RangePolicy policy(0, _c.extent(0)); + Kokkos::parallel_for(name.c_str(), policy, *this); + Kokkos::Profiling::popRegion(); + } + }; + + template + void impl_test_batched_eigendecomposition(const int N, const int m) { + + typedef Kokkos::View ViewRank3Type; + typedef Kokkos::View ViewRank2Type; + + /// input + ViewRank3Type A("A", N, m, m); + ViewRank2Type W("W", N, 2*m*m+m*5); + + /// output + ViewRank2Type Er("Er", N, m); + ViewRank2Type Ei("Ei", N, m); + ViewRank3Type UL("UL", N, m, m); + ViewRank3Type UR("UR", N, m, m); + + + Kokkos::Random_XorShift64_Pool random(13718); + Kokkos::fill_random(A, random, value_type(1.0)); + Kokkos::fence(); + + /// test body + Functor_TestBatchedSerialEigendecomposition + (A, Er, Ei, UL, UR, W).run(); + Kokkos::fence(); + } +} + +template +int test_batched_eigendecomposition() { +#if defined(KOKKOSKERNELS_INST_LAYOUTLEFT) + { + Test::impl_test_batched_eigendecomposition(0, 10); + for (int i=0;i<10;++i) { + Test::impl_test_batched_eigendecomposition(0, 1); + } + } +#endif +#if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) + { + Test::impl_test_batched_eigendecomposition(0, 10); + for (int i=0;i<10;++i) { + Test::impl_test_batched_eigendecomposition(0, 1); + } + } +#endif + + return 0; +} diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition_Real.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition_Real.hpp new file mode 100644 index 0000000000..5aaccb9e94 --- /dev/null +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition_Real.hpp @@ -0,0 +1,13 @@ +#if defined(KOKKOSKERNELS_INST_FLOAT) +TEST_F( TestCategory, batched_scalar_serial_eigendecomposition_float ) { + test_batched_eigendecomposition(); +} +#endif + +#if defined(KOKKOSKERNELS_INST_DOUBLE) +TEST_F( TestCategory, batched_scalar_serial_eigendecomposition_double ) { + test_batched_eigendecomposition(); +} +#endif + + diff --git a/unit_test/batched/Test_Batched_SerialSolveLU.hpp b/unit_test/batched/Test_Batched_SerialSolveLU.hpp index 2b014b9ac7..43b96a5dd7 100644 --- a/unit_test/batched/Test_Batched_SerialSolveLU.hpp +++ b/unit_test/batched/Test_Batched_SerialSolveLU.hpp @@ -11,7 +11,7 @@ #include "KokkosBatched_LU_Decl.hpp" #include "KokkosBatched_LU_Serial_Impl.hpp" #include "KokkosBatched_SolveLU_Decl.hpp" -#include "KokkosBatched_SolveLU_Serial_Impl.hpp" +//#include "KokkosBatched_SolveLU_Serial_Impl.hpp" #include "KokkosKernels_TestUtils.hpp" @@ -127,7 +127,7 @@ namespace Test { auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - SerialSolveLU::invoke(aa,bb); + SerialSolveLU::invoke(aa,bb); } inline diff --git a/unit_test/batched/Test_Batched_TeamInverseLU.hpp b/unit_test/batched/Test_Batched_TeamInverseLU.hpp index cefd97b732..430b6623cf 100644 --- a/unit_test/batched/Test_Batched_TeamInverseLU.hpp +++ b/unit_test/batched/Test_Batched_TeamInverseLU.hpp @@ -11,7 +11,7 @@ #include "KokkosBatched_LU_Decl.hpp" #include "KokkosBatched_LU_Team_Impl.hpp" #include "KokkosBatched_InverseLU_Decl.hpp" -#include "KokkosBatched_InverseLU_Team_Impl.hpp" +//#include "KokkosBatched_InverseLU_Team_Impl.hpp" #include "KokkosKernels_TestUtils.hpp" diff --git a/unit_test/batched/Test_Batched_TeamSolveLU.hpp b/unit_test/batched/Test_Batched_TeamSolveLU.hpp index 8b701d2109..54543d1845 100644 --- a/unit_test/batched/Test_Batched_TeamSolveLU.hpp +++ b/unit_test/batched/Test_Batched_TeamSolveLU.hpp @@ -11,7 +11,7 @@ #include "KokkosBatched_LU_Decl.hpp" #include "KokkosBatched_LU_Team_Impl.hpp" #include "KokkosBatched_SolveLU_Decl.hpp" -#include "KokkosBatched_SolveLU_Team_Impl.hpp" +//#include "KokkosBatched_SolveLU_Team_Impl.hpp" #include "KokkosKernels_TestUtils.hpp" @@ -143,7 +143,7 @@ namespace Test { auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - TeamSolveLU::invoke(member, aa, bb); + TeamSolveLU::invoke(member, aa, bb); } inline diff --git a/unit_test/cuda/Test_Cuda_Batched_SerialEigendecomposition_Real.cpp b/unit_test/cuda/Test_Cuda_Batched_SerialEigendecomposition_Real.cpp new file mode 100644 index 0000000000..7a0ed14829 --- /dev/null +++ b/unit_test/cuda/Test_Cuda_Batched_SerialEigendecomposition_Real.cpp @@ -0,0 +1,3 @@ +#include "Test_Cuda.hpp" +#include "Test_Batched_SerialEigendecomposition.hpp" +#include "Test_Batched_SerialEigendecomposition_Real.hpp" diff --git a/unit_test/openmp/Test_OpenMP_Batched_SerialEigendecomposition_Real.cpp b/unit_test/openmp/Test_OpenMP_Batched_SerialEigendecomposition_Real.cpp new file mode 100644 index 0000000000..e18601e9cd --- /dev/null +++ b/unit_test/openmp/Test_OpenMP_Batched_SerialEigendecomposition_Real.cpp @@ -0,0 +1,3 @@ +#include "Test_OpenMP.hpp" +#include "Test_Batched_SerialEigendecomposition.hpp" +#include "Test_Batched_SerialEigendecomposition_Real.hpp" diff --git a/unit_test/serial/Test_Serial_Batched_SerialEigendecomposition_Real.cpp b/unit_test/serial/Test_Serial_Batched_SerialEigendecomposition_Real.cpp new file mode 100644 index 0000000000..abe5e8c76d --- /dev/null +++ b/unit_test/serial/Test_Serial_Batched_SerialEigendecomposition_Real.cpp @@ -0,0 +1,3 @@ +#include "Test_Serial.hpp" +#include "Test_Batched_SerialEigendecomposition.hpp" +#include "Test_Batched_SerialEigendecomposition_Real.hpp" From 87eea3f0d0da89901f211a4b10c20799936eae90 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:15:01 -0700 Subject: [PATCH 114/190] KokkosBatched - add missing files --- .../KokkosBatched_SetIdentity_Decl.hpp | 38 +++++++++++++++ .../KokkosBatched_SetIdentity_Impl.hpp | 48 +++++++++++++++++++ .../KokkosBatched_SetIdentity_Internal.hpp | 25 ++++++++++ 3 files changed, 111 insertions(+) create mode 100644 src/batched/KokkosBatched_SetIdentity_Decl.hpp create mode 100644 src/batched/KokkosBatched_SetIdentity_Impl.hpp diff --git a/src/batched/KokkosBatched_SetIdentity_Decl.hpp b/src/batched/KokkosBatched_SetIdentity_Decl.hpp new file mode 100644 index 0000000000..69168b64e2 --- /dev/null +++ b/src/batched/KokkosBatched_SetIdentity_Decl.hpp @@ -0,0 +1,38 @@ +#ifndef __KOKKOSBATCHED_SET_IDENTITY_DECL_HPP__ +#define __KOKKOSBATCHED_SET_IDENTITY_DECL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial SetIdentity + /// + + struct SerialSetIdentity { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A); + }; + + /// + /// Team Set + /// + + template + struct TeamSetIdentity { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A); + }; + + } +} + + +#endif diff --git a/src/batched/KokkosBatched_SetIdentity_Impl.hpp b/src/batched/KokkosBatched_SetIdentity_Impl.hpp new file mode 100644 index 0000000000..4cd7da82da --- /dev/null +++ b/src/batched/KokkosBatched_SetIdentity_Impl.hpp @@ -0,0 +1,48 @@ +#ifndef __KOKKOSBATCHED_SET_IDENTITY_IMPL_HPP__ +#define __KOKKOSBATCHED_SET_IDENTITY_IMPL_HPP__ + + +/// \author Kyungjoo Kim (kyukim@sandia.gov) + +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_SetIdentity_Internal.hpp" + + +namespace KokkosBatched { + namespace Experimental { + /// + /// Serial Impl + /// =========== + + template + KOKKOS_INLINE_FUNCTION + int + SerialSetIdentity:: + invoke(const AViewType &A) { + return SerialSetIdentityInternal:: + invoke(A.extent(0), + A.data(), A.stride_0(), A.stride_1()); + } + + /// + /// Team Impl + /// ========= + + template + template + KOKKOS_INLINE_FUNCTION + int + TeamSetIdentity:: + invoke(const MemberType &member, + const AViewType &A) { + return TeamSetIdentityInternal:: + invoke(member, + A.extent(0), + A.data(), A.stride_0(), A.stride_1()); + } + + } // end namespace Experimental +} //end namespace KokkosBatched + + +#endif diff --git a/src/batched/KokkosBatched_SetIdentity_Internal.hpp b/src/batched/KokkosBatched_SetIdentity_Internal.hpp index a0d7816143..7965905cd9 100644 --- a/src/batched/KokkosBatched_SetIdentity_Internal.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Internal.hpp @@ -32,6 +32,31 @@ namespace KokkosBatched { } }; + /// + /// Team Internal Impl + /// ================== + template + struct TeamSetIdentityInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(MemberType const int m, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + const ValueType one(1), zero(0); + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,m), + [&](const int &i) { +#if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) +#pragma unroll +#endif + for (int j=0;j Date: Wed, 13 Feb 2019 16:21:01 -0700 Subject: [PATCH 115/190] KokkosBatched - add missing headers. --- src/batched/KokkosBatched_AddRadial_Decl.hpp | 2 ++ src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp | 2 ++ src/batched/KokkosBatched_Copy_Decl.hpp | 2 ++ src/batched/KokkosBatched_Eigendecomposition_Decl.hpp | 3 +++ src/batched/KokkosBatched_Gemm_Decl.hpp | 2 ++ src/batched/KokkosBatched_Gemv_Decl.hpp | 3 +++ src/batched/KokkosBatched_Householder_Decl.hpp | 3 +++ src/batched/KokkosBatched_LU_Decl.hpp | 1 + src/batched/KokkosBatched_Scale_Decl.hpp | 3 +++ src/batched/KokkosBatched_SetIdentity_Decl.hpp | 3 +++ src/batched/KokkosBatched_Set_Decl.hpp | 3 +++ src/batched/KokkosBatched_SolveLU_Decl.hpp | 1 + src/batched/KokkosBatched_Trsm_Decl.hpp | 3 +++ src/batched/KokkosBatched_Trsv_Decl.hpp | 3 +++ 14 files changed, 34 insertions(+) diff --git a/src/batched/KokkosBatched_AddRadial_Decl.hpp b/src/batched/KokkosBatched_AddRadial_Decl.hpp index c4d6adfe1e..fbe4fa2c17 100644 --- a/src/batched/KokkosBatched_AddRadial_Decl.hpp +++ b/src/batched/KokkosBatched_AddRadial_Decl.hpp @@ -4,6 +4,8 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp index 13421f82b0..df2c529708 100644 --- a/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp +++ b/src/batched/KokkosBatched_ApplyHouseholder_Decl.hpp @@ -4,6 +4,8 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Copy_Decl.hpp b/src/batched/KokkosBatched_Copy_Decl.hpp index 2b69586251..fc552dde77 100644 --- a/src/batched/KokkosBatched_Copy_Decl.hpp +++ b/src/batched/KokkosBatched_Copy_Decl.hpp @@ -4,6 +4,8 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp index 71742047f3..1a36d243a7 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition diff --git a/src/batched/KokkosBatched_Gemm_Decl.hpp b/src/batched/KokkosBatched_Gemm_Decl.hpp index cd5f1bd302..a4c2ead53f 100644 --- a/src/batched/KokkosBatched_Gemm_Decl.hpp +++ b/src/batched/KokkosBatched_Gemm_Decl.hpp @@ -4,6 +4,8 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Gemv_Decl.hpp b/src/batched/KokkosBatched_Gemv_Decl.hpp index ed910469dc..98ab2916db 100644 --- a/src/batched/KokkosBatched_Gemv_Decl.hpp +++ b/src/batched/KokkosBatched_Gemv_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Householder_Decl.hpp b/src/batched/KokkosBatched_Householder_Decl.hpp index 60e97053fc..dc06dd2e77 100644 --- a/src/batched/KokkosBatched_Householder_Decl.hpp +++ b/src/batched/KokkosBatched_Householder_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_LU_Decl.hpp b/src/batched/KokkosBatched_LU_Decl.hpp index 3ffcedde36..8113d4a65c 100644 --- a/src/batched/KokkosBatched_LU_Decl.hpp +++ b/src/batched/KokkosBatched_LU_Decl.hpp @@ -4,6 +4,7 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" namespace KokkosBatched { diff --git a/src/batched/KokkosBatched_Scale_Decl.hpp b/src/batched/KokkosBatched_Scale_Decl.hpp index 53627fd970..26d897d407 100644 --- a/src/batched/KokkosBatched_Scale_Decl.hpp +++ b/src/batched/KokkosBatched_Scale_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_SetIdentity_Decl.hpp b/src/batched/KokkosBatched_SetIdentity_Decl.hpp index 69168b64e2..64100bd826 100644 --- a/src/batched/KokkosBatched_SetIdentity_Decl.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Set_Decl.hpp b/src/batched/KokkosBatched_Set_Decl.hpp index 3b9d50ce60..ee1befe9ff 100644 --- a/src/batched/KokkosBatched_Set_Decl.hpp +++ b/src/batched/KokkosBatched_Set_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_SolveLU_Decl.hpp b/src/batched/KokkosBatched_SolveLU_Decl.hpp index 400b45fd59..c6cff781f8 100644 --- a/src/batched/KokkosBatched_SolveLU_Decl.hpp +++ b/src/batched/KokkosBatched_SolveLU_Decl.hpp @@ -4,6 +4,7 @@ /// \author Vinh Dang (vqdang@sandia.gov) +#include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" #include "KokkosBatched_Trsm_Decl.hpp" #include "KokkosBatched_Trsm_Serial_Impl.hpp" diff --git a/src/batched/KokkosBatched_Trsm_Decl.hpp b/src/batched/KokkosBatched_Trsm_Decl.hpp index dce98acac4..24f39dc6c2 100644 --- a/src/batched/KokkosBatched_Trsm_Decl.hpp +++ b/src/batched/KokkosBatched_Trsm_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { diff --git a/src/batched/KokkosBatched_Trsv_Decl.hpp b/src/batched/KokkosBatched_Trsv_Decl.hpp index f7d5391921..b31cddeaf2 100644 --- a/src/batched/KokkosBatched_Trsv_Decl.hpp +++ b/src/batched/KokkosBatched_Trsv_Decl.hpp @@ -4,6 +4,9 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + namespace KokkosBatched { namespace Experimental { From cfe414fd506712e09ec119ce6a3aa7ed2f1abd03 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:30:13 -0700 Subject: [PATCH 116/190] KokkosBatched- zero block matrix return zero --- src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp index 4575aa5f41..1b86c6e2d8 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp @@ -38,14 +38,14 @@ namespace KokkosBatched { /// static assert A,er,ei,UL,UR,W has the same value_type /// static assert all views have the same memory space - return SerialEigendecompositionInternal + return m ? SerialEigendecompositionInternal ::invoke(A.extent(0), A.data(), A.stride(0), A.stride(1), er.data(), er.stride(0), ei.data(), ei.stride(0), UL.data(), UL.stride(0), UL.stride(1), UR.data(), UR.stride(0), UR.stride(1), - W.data(), W.extent(0)); + W.data(), W.extent(0)) : 0; } }/// end namespace Experimental From 7fcad95147c086e5d813994fcea24dd095983764 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:31:17 -0700 Subject: [PATCH 117/190] KokkosBatched - fix typo --- src/batched/KokkosBatched_SolveLU_Decl.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/batched/KokkosBatched_SolveLU_Decl.hpp b/src/batched/KokkosBatched_SolveLU_Decl.hpp index c6cff781f8..f12561690d 100644 --- a/src/batched/KokkosBatched_SolveLU_Decl.hpp +++ b/src/batched/KokkosBatched_SolveLU_Decl.hpp @@ -77,7 +77,7 @@ namespace KokkosBatched { struct SolveLU { // no piv version template + typename BViewType> KOKKOS_FORCEINLINE_FUNCTION static int invoke(const MemberType &member, From 1808424cf7a434c230ffb8ffaebc5bb541d25c54 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:34:53 -0700 Subject: [PATCH 118/190] KokkosBatched - fix misc --- src/batched/KokkosBatched_SetIdentity_Internal.hpp | 7 ++++--- .../batched/Test_Batched_SerialEigendecomposition.hpp | 6 +++--- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/batched/KokkosBatched_SetIdentity_Internal.hpp b/src/batched/KokkosBatched_SetIdentity_Internal.hpp index 7965905cd9..1c4e653b31 100644 --- a/src/batched/KokkosBatched_SetIdentity_Internal.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Internal.hpp @@ -35,12 +35,13 @@ namespace KokkosBatched { /// /// Team Internal Impl /// ================== - template struct TeamSetIdentityInternal { - template + template KOKKOS_INLINE_FUNCTION static int - invoke(MemberType const int m, + invoke(const MemberType &member, + const int m, /* */ ValueType *__restrict__ A, const int as0, const int as1) { const ValueType one(1), zero(0); Kokkos::parallel_for diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp index d8a01a98dc..79566a32e4 100644 --- a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp @@ -67,9 +67,9 @@ namespace Test { typename ValueType, typename LayoutType> void impl_test_batched_eigendecomposition(const int N, const int m) { - - typedef Kokkos::View ViewRank3Type; - typedef Kokkos::View ViewRank2Type; + typedef ValueType value_type; + typedef Kokkos::View ViewRank3Type; + typedef Kokkos::View ViewRank2Type; /// input ViewRank3Type A("A", N, m, m); From b517a510bd8175d27ac27913d91d76b12d854988 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:54:08 -0700 Subject: [PATCH 119/190] KokkosBatched - fix misc --- src/batched/KokkosBatched_InverseLU_Decl.hpp | 9 ++++---- src/batched/KokkosBatched_SolveLU_Decl.hpp | 22 +++++++++++-------- .../Test_Batched_SerialEigendecomposition.hpp | 4 ++-- 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/src/batched/KokkosBatched_InverseLU_Decl.hpp b/src/batched/KokkosBatched_InverseLU_Decl.hpp index 3b9e4cbc7c..e6029002d7 100644 --- a/src/batched/KokkosBatched_InverseLU_Decl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Decl.hpp @@ -9,6 +9,7 @@ #include "KokkosBatched_Copy_Impl.hpp" #include "KokkosBatched_SetIdentity_Decl.hpp" #include "KokkosBatched_SetIdentity_Impl.hpp" +#include "KokkosBatched_SolveLU_Decl.hpp" namespace KokkosBatched { namespace Experimental { @@ -23,7 +24,7 @@ namespace KokkosBatched { const WViewType &W) { SerialCopy::invoke(A, W); SerialSetIdentity::invoke(A); - SerialSolveLU::invoke(A,B); + SerialSolveLU::invoke(W, A); } }; @@ -37,9 +38,9 @@ namespace KokkosBatched { invoke(const MemberType &member, const AViewType &A, const WViewType &W) { - TeamCopy::invoke(A, W); - TeamSetIdentity::invoke(A); - TeamSolveLU::invoke(A,B); + TeamCopy::invoke(member, A, W); + TeamSetIdentity::invoke(member, A); + TeamSolveLU::invoke(member, W, A); } }; diff --git a/src/batched/KokkosBatched_SolveLU_Decl.hpp b/src/batched/KokkosBatched_SolveLU_Decl.hpp index f12561690d..6a811609da 100644 --- a/src/batched/KokkosBatched_SolveLU_Decl.hpp +++ b/src/batched/KokkosBatched_SolveLU_Decl.hpp @@ -23,19 +23,21 @@ namespace KokkosBatched { static int invoke(const AViewType &A, const BViewType &B) { + int r_val_1(0), r_val_2(0); const typename AViewType::non_const_value_type one(1.0); if (std::is_same::value) { //First, compute Y (= U*X) by solving the system L*Y = B for Y - SerialTrsm::invoke(one, A, B); + r_val_1 = SerialTrsm::invoke(one, A, B); //Second, compute X by solving the system U*X = Y for X - SerialTrsm::invoke(one, A, B); + r_val_2 = SerialTrsm::invoke(one, A, B); } else if (std::is_same::value || std::is_same::value) { //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - SerialTrsm::invoke(one, A, B); + r_val_1 = SerialTrsm::invoke(one, A, B); //Second, compute X by solving the system L'*X = Y for X - SerialTrsm::invoke(one, A, B); + r_val_2 = SerialTrsm::invoke(one, A, B); } + return r_val_1 + r_val_2; } }; @@ -51,19 +53,21 @@ namespace KokkosBatched { invoke(const MemberType &member, const AViewType &A, const BViewType &B) { + int r_val_1(0), r_val_2(0); const typename AViewType::non_const_value_type one(1.0); if (std::is_same::value) { //First, compute Y (= U*X) by solving the system L*Y = B for Y - TeamTrsm::invoke(member, one, A, B); + r_val_1 = TeamTrsm::invoke(member, one, A, B); //Second, compute X by solving the system U*X = Y for X - TeamTrsm::invoke(member, one, A, B); + r_val_2 = TeamTrsm::invoke(member, one, A, B); } else if (std::is_same::value || std::is_same::value) { //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - TeamTrsm::invoke(member, one, A, B); + r_val_1 = TeamTrsm::invoke(member, one, A, B); //Second, compute X by solving the system L'*X = Y for X - TeamTrsm::invoke(member, one, A, B); + r_val_2 = TeamTrsm::invoke(member, one, A, B); } + return r_val_1 + r_val_2; } }; @@ -87,7 +91,7 @@ namespace KokkosBatched { if (std::is_same::value) { r_val = SerialSolveLU::invoke(A, B); } else if (std::is_same::value) { - r_val = TeamLU::invoke(member, A, B); + r_val = TeamSolveLU::invoke(member, A, B); } return r_val; } diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp index 79566a32e4..ea993b5d6b 100644 --- a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp @@ -49,7 +49,7 @@ namespace Test { inline void run() { - typedef typename ViewType::value_type value_type; + typedef typename ViewRank3Type::value_type value_type; std::string name_region("KokkosBatched::Test::SerialEigendecomposition"); std::string name_value_type = ( std::is_same::value ? "::Float" : std::is_same::value ? "::Double" : @@ -57,7 +57,7 @@ namespace Test { std::is_same >::value ? "::ComplexDouble" : "::UnknownValueType" ); std::string name = name_region + name_value_type; Kokkos::Profiling::pushRegion( name.c_str() ); - Kokkos::RangePolicy policy(0, _c.extent(0)); + Kokkos::RangePolicy policy(0, _A.extent(0)); Kokkos::parallel_for(name.c_str(), policy, *this); Kokkos::Profiling::popRegion(); } From 44200f21ce24444c8480a12e3b5a4ff978e99936 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 16:58:03 -0700 Subject: [PATCH 120/190] KokkosBatched - hope this is the last misc fix --- src/batched/KokkosBatched_InverseLU_Decl.hpp | 16 ++++++++----- src/batched/KokkosBatched_SolveLU_Decl.hpp | 24 ++++++++++---------- 2 files changed, 22 insertions(+), 18 deletions(-) diff --git a/src/batched/KokkosBatched_InverseLU_Decl.hpp b/src/batched/KokkosBatched_InverseLU_Decl.hpp index e6029002d7..0bb022a41c 100644 --- a/src/batched/KokkosBatched_InverseLU_Decl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Decl.hpp @@ -22,9 +22,11 @@ namespace KokkosBatched { static int invoke(const AViewType &A, const WViewType &W) { - SerialCopy::invoke(A, W); - SerialSetIdentity::invoke(A); - SerialSolveLU::invoke(W, A); + int r_val[3] = {}; + r_val[0] = SerialCopy::invoke(A, W); + r_val[1] = SerialSetIdentity::invoke(A); + r_val[2] = SerialSolveLU::invoke(W, A); + return r_val[0]+r_val[1]+r_val[2]; } }; @@ -38,9 +40,11 @@ namespace KokkosBatched { invoke(const MemberType &member, const AViewType &A, const WViewType &W) { - TeamCopy::invoke(member, A, W); - TeamSetIdentity::invoke(member, A); - TeamSolveLU::invoke(member, W, A); + int r_val[3] = {}; + r_val[0] = TeamCopy::invoke(member, A, W); + r_val[1] = TeamSetIdentity::invoke(member, A); + r_val[2] = TeamSolveLU::invoke(member, W, A); + return r_val[0]+r_val[1]+r_val[2]; } }; diff --git a/src/batched/KokkosBatched_SolveLU_Decl.hpp b/src/batched/KokkosBatched_SolveLU_Decl.hpp index 6a811609da..8f088db2d4 100644 --- a/src/batched/KokkosBatched_SolveLU_Decl.hpp +++ b/src/batched/KokkosBatched_SolveLU_Decl.hpp @@ -23,21 +23,21 @@ namespace KokkosBatched { static int invoke(const AViewType &A, const BViewType &B) { - int r_val_1(0), r_val_2(0); + int r_val[2] = {}; const typename AViewType::non_const_value_type one(1.0); if (std::is_same::value) { //First, compute Y (= U*X) by solving the system L*Y = B for Y - r_val_1 = SerialTrsm::invoke(one, A, B); + r_val[0] = SerialTrsm::invoke(one, A, B); //Second, compute X by solving the system U*X = Y for X - r_val_2 = SerialTrsm::invoke(one, A, B); + r_val[1] = SerialTrsm::invoke(one, A, B); } else if (std::is_same::value || std::is_same::value) { //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - r_val_1 = SerialTrsm::invoke(one, A, B); + r_val[0] = SerialTrsm::invoke(one, A, B); //Second, compute X by solving the system L'*X = Y for X - r_val_2 = SerialTrsm::invoke(one, A, B); + r_val[1] = SerialTrsm::invoke(one, A, B); } - return r_val_1 + r_val_2; + return r_val[0]+r_val[1]; } }; @@ -53,21 +53,21 @@ namespace KokkosBatched { invoke(const MemberType &member, const AViewType &A, const BViewType &B) { - int r_val_1(0), r_val_2(0); + int r_val[2] = {}; const typename AViewType::non_const_value_type one(1.0); if (std::is_same::value) { //First, compute Y (= U*X) by solving the system L*Y = B for Y - r_val_1 = TeamTrsm::invoke(member, one, A, B); + r_val[0] = TeamTrsm::invoke(member, one, A, B); //Second, compute X by solving the system U*X = Y for X - r_val_2 = TeamTrsm::invoke(member, one, A, B); + r_val[1] = TeamTrsm::invoke(member, one, A, B); } else if (std::is_same::value || std::is_same::value) { //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - r_val_1 = TeamTrsm::invoke(member, one, A, B); + r_val[0] = TeamTrsm::invoke(member, one, A, B); //Second, compute X by solving the system L'*X = Y for X - r_val_2 = TeamTrsm::invoke(member, one, A, B); + r_val[1] = TeamTrsm::invoke(member, one, A, B); } - return r_val_1 + r_val_2; + return r_val[0]+r_val[1]; } }; From 394048e0e10fe1e421c52dad9054e188e0a12078 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 13 Feb 2019 17:27:47 -0700 Subject: [PATCH 121/190] KokkosBatched - typo fix --- unit_test/batched/Test_Batched_SerialInverseLU.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/unit_test/batched/Test_Batched_SerialInverseLU.hpp b/unit_test/batched/Test_Batched_SerialInverseLU.hpp index 34296a2124..e3695c96c5 100644 --- a/unit_test/batched/Test_Batched_SerialInverseLU.hpp +++ b/unit_test/batched/Test_Batched_SerialInverseLU.hpp @@ -11,7 +11,7 @@ #include "KokkosBatched_LU_Decl.hpp" #include "KokkosBatched_LU_Serial_Impl.hpp" #include "KokkosBatched_InverseLU_Decl.hpp" -#include "KokkosBatched_InverseLU_Serial_Impl.hpp" +//#include "KokkosBatched_InverseLU_Serial_Impl.hpp" #include "KokkosKernels_TestUtils.hpp" From 0b3defb8c52813c80eb9913b3dac579868c91961 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 13 Feb 2019 17:41:49 -0700 Subject: [PATCH 122/190] D2Coloring: reviewer requests --- perf_test/graph/KokkosGraph_color_d2.cpp | 221 ++++------------------- src/graph/KokkosGraph_GraphColor.hpp | 2 + src/graph/KokkosGraph_graph_color.hpp | 3 + 3 files changed, 39 insertions(+), 187 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 2ad3bc4d42..995cf3260f 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -598,33 +598,17 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) template -void run_multi_mem_experiment(Parameters params) +void experiment_driver(Parameters params) { using myExecSpace = exec_space; using myFastDevice = Kokkos::Device; - using mySlowExecSpace = Kokkos::Device; using fast_crstmat_t = typename MyKokkosSparse::CrsMatrix; using fast_graph_t = typename fast_crstmat_t::StaticCrsGraphType; - // typedef typename fast_graph_t::row_map_type::non_const_type fast_row_map_view_t; - // typedef typename fast_graph_t::entries_type::non_const_type fast_cols_view_t; - // typedef typename fast_graph_t::row_map_type::const_type const_fast_row_map_view_t; - // typedef typename fast_graph_t::entries_type::const_type const_fast_cols_view_t; - - using slow_crstmat_t = typename MyKokkosSparse::CrsMatrix; - using slow_graph_t = typename slow_crstmat_t::StaticCrsGraphType; - - // typedef typename slow_graph_t::row_map_type::non_const_type slow_row_map_view_t; - // typedef typename slow_graph_t::entries_type::non_const_type slow_cols_view_t; - // typedef typename slow_graph_t::row_map_type::const_type const_slow_row_map_view_t; - // typedef typename slow_graph_t::entries_type::const_type const_slow_cols_view_t; - char *a_mat_file = params.a_mtx_bin_file; - slow_graph_t a_slow_crsgraph, /*b_slow_crsgraph,*/ c_slow_crsgraph; fast_graph_t a_fast_crsgraph, /*b_fast_crsgraph,*/ c_fast_crsgraph; - // read a and b matrices and store them on slow or fast memory. if(params.a_mem_space == 1) { fast_crstmat_t a_fast_crsmat; @@ -632,158 +616,19 @@ void run_multi_mem_experiment(Parameters params) a_fast_crsgraph = a_fast_crsmat.graph; a_fast_crsgraph.num_cols = a_fast_crsmat.numCols(); } - else - { - slow_crstmat_t a_slow_crsmat; - a_slow_crsmat = KokkosKernels::Impl::read_kokkos_crst_matrix(a_mat_file); - a_slow_crsgraph = a_slow_crsmat.graph; - a_slow_crsgraph.num_cols = a_slow_crsmat.numCols(); - } - if(params.a_mem_space == 1) + if(params.a_mem_space == 1 && params.b_mem_space==1 && params.c_mem_space==1 && params.work_mem_space==1) { - if(params.b_mem_space == 1) - { - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - } - else - { - // B is in slow memory - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_fast_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - } + KokkosKernels::Experiment::run_experiment + (a_fast_crsgraph, /*b_fast_crsgraph,*/ params); } else { - // A is in slow memory - if(params.b_mem_space == 1) - { - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_fast_crsgraph,*/ params); - } - } - } - else - { - // B is in slow memory - if(params.c_mem_space == 1) - { - if(params.work_mem_space == 1) - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /* c_fast_crsgraph = */ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - else - { - // C is in slow memory. - if(params.work_mem_space == 1) - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - else - { - /*c_slow_crsgraph =*/ - KokkosKernels::Experiment::run_experiment(a_slow_crsgraph, - /*b_slow_crsgraph,*/ params); - } - } - } + std::cout << ">>> unhandled memspace configuration flags:" << std::endl + << ">>> a_mem_space = " << params.a_mem_space << std::endl + << ">>> b_mem_space = " << params.a_mem_space << std::endl + << ">>> c_mem_space = " << params.a_mem_space << std::endl + << ">>> work_mem_space = " << params.work_mem_space << std::endl; } } @@ -821,40 +666,42 @@ int main(int argc, char *argv[]) // Print out verbose information about the configuration of the run. // Kokkos::print_configuration(std::cout); -#if defined(KOKKOS_ENABLE_OPENMP) + #if defined(KOKKOS_MULTI_MEM) + const bool use_multi_mem = true; + // todo: Throw an error or print a message if KOKKOS_MULTI_MEM is enabled for this test? (WCMCLEN--SCAFFOLDING) + #else + const bool use_multi_mem = false; + #endif + + #if defined(KOKKOS_ENABLE_OPENMP) if(params.use_openmp) { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif + if(!use_multi_mem) + { + KokkosKernels::Experiment::experiment_driver(params); + } } -#endif - + #endif -#if defined(KOKKOS_ENABLE_CUDA) + #if defined(KOKKOS_ENABLE_CUDA) if(params.use_cuda) { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif + if(!use_multi_mem) + { + KokkosKernels::Experiment::experiment_driver(params); + } } -#endif - + #endif -#if defined(KOKKOS_ENABLE_SERIAL) + #if defined(KOKKOS_ENABLE_SERIAL) if(params.use_serial) { -#ifdef KOKKOSKERNELS_MULTI_MEM - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#else - KokkosKernels::Experiment::run_multi_mem_experiment(params); -#endif + if(!use_multi_mem) + { + KokkosKernels::Experiment::experiment_driver(params); + } } -#endif + #endif Kokkos::finalize(); diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_GraphColor.hpp index 999edf7d8f..e3d6de7069 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_GraphColor.hpp @@ -174,6 +174,8 @@ void d2_graph_color( break; } + // TODO: SCAFFOLDING: Remove SERIAL Distance-2 Graph Coloring from this interface + // case COLORING_SERIAL2: { color_view_type colors_out = color_view_type("Graph Colors", num_rows); diff --git a/src/graph/KokkosGraph_graph_color.hpp b/src/graph/KokkosGraph_graph_color.hpp index 26b4ac3bb7..f35f1939c4 100644 --- a/src/graph/KokkosGraph_graph_color.hpp +++ b/src/graph/KokkosGraph_graph_color.hpp @@ -50,3 +50,6 @@ */ #include "KokkosGraph_GraphColor.hpp" +// TODO: SCAFFOLDING (Add a deprecation warning that this will go away in version 3.0) + + From b4e7c105407dbabf2b6ff2cf8b9a73a9decf3d11 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 13 Feb 2019 18:00:03 -0700 Subject: [PATCH 123/190] D2GC: Moved some helper/convenience functions into impl --- perf_test/graph/KokkosGraph_color_d2.cpp | 8 +- src/graph/KokkosGraph_Distance2Color.hpp | 149 +---------------- src/graph/KokkosGraph_GraphColor.hpp | 2 +- ...pp => KokkosGraph_Distance1Color_impl.hpp} | 0 .../impl/KokkosGraph_Distance2Color_impl.hpp | 152 ++++++++++++++++++ 5 files changed, 158 insertions(+), 153 deletions(-) rename src/graph/impl/{KokkosGraph_GraphColor_impl.hpp => KokkosGraph_Distance1Color_impl.hpp} (100%) diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index 995cf3260f..f8ae2b786b 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -393,7 +393,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) bool d2_coloring_is_valid = false; bool d2_coloring_validation_flags[4] = { false }; - d2_coloring_is_valid = graph_verify_distance2_color(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, d2_coloring_validation_flags); + d2_coloring_is_valid = KokkosGraph::Impl::graph_verify_distance2_color(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, d2_coloring_validation_flags); // Print out messages based on coloring validation check. if(d2_coloring_is_valid) @@ -419,7 +419,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) // ------------------------------------------ // Print out the colors histogram // ------------------------------------------ - graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); + KokkosGraph::Impl::graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, false); } // for i... @@ -438,7 +438,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) non_const_1d_size_type_view_t degree_d2_dist = non_const_1d_size_type_view_t("degree d2", crsGraph.numRows()); size_t degree_d2_max=0; - graph_compute_distance2_degree(&kh, crsGraph.numRows(), crsGraph.numCols(), + KokkosGraph::Impl::graph_compute_distance2_degree(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, degree_d2_dist, degree_d2_max); @@ -590,7 +590,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) << "," << label_algorithm << "," << Kokkos::DefaultExecutionSpace::concurrency() << ","; - graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); + KokkosGraph::Impl::graph_print_distance2_color_histogram(&kh, crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries, crsGraph.row_map, crsGraph.entries, true); std::cout << std::endl; // Kokkos::print_configuration(std::cout); diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index e21f61c835..4f879c5090 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -45,7 +45,7 @@ #include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosGraph_GraphColorDistance2Handle.hpp" -#include "KokkosGraph_GraphColor_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? +#include "KokkosGraph_Distance1Color_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" @@ -155,153 +155,6 @@ void graph_compute_distance2_color(KernelHandle *handle, } -/** - * Compute Distance-2 Degree Stats - * - * Distance-2 Degree of a vertex, v, is the sum of the unique paths from u to v - * where v is 2 hops from u. (i.e., paths like: `u -> * -> v`) - * - * This function calculates the distance-2 degree of all the vertices in the graph, - * the maximum distance-2 degree. - * - * If the graph is symmetric, give the same value for col_map and row_map, - * and for row_entries and col_entries. - * - * @param[in] handle The Kernel Handle - * @param[in] num_rows Number of rows in the matrix (number of vertices) - * @param[in] num_cols Number of columns in the matrix - * @param[in] row_map Row map - * @param[in] row_entries Row entries - * @param[in] col_map Column map - * @param[in] col_entries Column entries - * @param[out] degree_d2_dist View to fill with distance-2 degree information. - * @param[out] degree_d2_max Maximum distance-2 degree found. - * - * @return Nothing - * - * Note: This is currently EXPERIMENTAL. - */ -template -void graph_compute_distance2_degree(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, - size_t& degree_d2_max) -{ - typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - - Impl::GraphColorDistance2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - - gc.compute_distance2_degree(degree_d2_dist, degree_d2_max); -} - - - -/** - * Validate Distance 2 Graph Coloring - * - * If the graph is symmetric, give the same value for col_map and row_map, - * and for row_entries and col_entries. - * - * @param[in] handle The kernel handle - * @param[in] num_rows Number of rows in the matrix (number of vertices) - * @param[in] num_cols Number of columns in the matrix - * @param[in] row_map The row map - * @param[in] row_entries The row entries - * @param[in] col_map The column map - * @param[in] col_entries The column entries - * @param[out] validation_flags An array of 4 booleans. - * validation_flags[0] : True IF the distance-2 coloring is invalid. - * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. - * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices - * at distance=2 from each other has the same color. - * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. - * May not be an INVALID coloring, but can indicate poor quality in coloring. - * - * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. - */ -template -bool graph_verify_distance2_color(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - bool validation_flags[]) -{ - bool output = true; - - typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - - Impl::GraphColorDistance2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - - output = gc.verify_coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); - - return output; -} - - - -/** - * Prints out a histogram of graph colors for Distance-2 Graph Coloring - * - * If the graph is symmetric, give the same value for col_map and row_map, - * and for row_entries and col_entries. - * - * @param[in] handle The kernel handle - * @param[in] num_rows Number of rows in the matrix (number of vertices) - * @param[in] num_cols Number of columns in the matrix - * @param[in] row_map The row map - * @param[in] row_entries The row entries - * @param[in] col_map The column map - * @param[in] col_entries The column entries - * @param[out] validation_flags An array of 4 booleans. - * validation_flags[0] : True IF the distance-2 coloring is invalid. - * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. - * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices - * at distance=2 from each other has the same color. - * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. - * May not be an INVALID coloring, but can indicate poor quality in coloring. - * @param[in] csv Output in CSV format? Default: false - * - * @return nothing - */ -template -void graph_print_distance2_color_histogram(KernelHandle *handle, - typename KernelHandle::nnz_lno_t num_rows, - typename KernelHandle::nnz_lno_t num_cols, - lno_row_view_t_ row_map, - lno_nnz_view_t_ row_entries, - // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. - lno_col_view_t_ col_map, - lno_colnnz_view_t_ col_entries, - bool csv=false) -{ - typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); - - Impl::GraphColorDistance2 - gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); - - if(csv) - { - gc.print_color_histogram_csv(); - } - else - { - gc.print_color_histogram(); - } -} - - - } // end namespace Experimental } // end namespace KokkosGraph diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_GraphColor.hpp index e3d6de7069..ed8bdc6fea 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_GraphColor.hpp @@ -45,7 +45,7 @@ #include -#include "KokkosGraph_GraphColor_impl.hpp" +#include "KokkosGraph_Distance1Color_impl.hpp" #include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" diff --git a/src/graph/impl/KokkosGraph_GraphColor_impl.hpp b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp similarity index 100% rename from src/graph/impl/KokkosGraph_GraphColor_impl.hpp rename to src/graph/impl/KokkosGraph_Distance1Color_impl.hpp diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index c9a7ac63b9..730b8c1728 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1647,6 +1647,158 @@ class GraphColorDistance2 }; // end class GraphColorDistance2 + + +/** + * Compute Distance-2 Degree Stats + * + * Distance-2 Degree of a vertex, v, is the sum of the unique paths from u to v + * where v is 2 hops from u. (i.e., paths like: `u -> * -> v`) + * + * This function calculates the distance-2 degree of all the vertices in the graph, + * the maximum distance-2 degree. + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @param[in] handle The Kernel Handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map Row map + * @param[in] row_entries Row entries + * @param[in] col_map Column map + * @param[in] col_entries Column entries + * @param[out] degree_d2_dist View to fill with distance-2 degree information. + * @param[out] degree_d2_max Maximum distance-2 degree found. + * + * @return Nothing + * + * Note: This is currently EXPERIMENTAL. + */ +template +void graph_compute_distance2_degree(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + typename KernelHandle::GraphColoringHandleType::non_const_1d_size_type_view_t& degree_d2_dist, + size_t& degree_d2_max) +{ + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + + Impl::GraphColorDistance2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); + + gc.compute_distance2_degree(degree_d2_dist, degree_d2_max); +} + + + + +/** + * Validate Distance 2 Graph Coloring + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @param[in] handle The kernel handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map The row map + * @param[in] row_entries The row entries + * @param[in] col_map The column map + * @param[in] col_entries The column entries + * @param[out] validation_flags An array of 4 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. + * May not be an INVALID coloring, but can indicate poor quality in coloring. + * + * @return boolean that is TRUE if the Distance-2 coloring is valid. False if otherwise. + */ +template +bool graph_verify_distance2_color(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + bool validation_flags[]) +{ + bool output = true; + + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + + Impl::GraphColorDistance2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); + + output = gc.verify_coloring(row_map, row_entries, col_map, col_entries, gch_d2->get_vertex_colors(), validation_flags); + + return output; +} + + + + +/** + * Prints out a histogram of graph colors for Distance-2 Graph Coloring + * + * If the graph is symmetric, give the same value for col_map and row_map, + * and for row_entries and col_entries. + * + * @param[in] handle The kernel handle + * @param[in] num_rows Number of rows in the matrix (number of vertices) + * @param[in] num_cols Number of columns in the matrix + * @param[in] row_map The row map + * @param[in] row_entries The row entries + * @param[in] col_map The column map + * @param[in] col_entries The column entries + * @param[out] validation_flags An array of 4 booleans. + * validation_flags[0] : True IF the distance-2 coloring is invalid. + * validation_flags[1] : True IF the coloring is bad because vertices are left uncolored. + * validation_flags[2] : True IF the coloring is bad because at least one pair of vertices + * at distance=2 from each other has the same color. + * validation_flags[3] : True IF a vertex has a color greater than number of vertices in the graph. + * May not be an INVALID coloring, but can indicate poor quality in coloring. + * @param[in] csv Output in CSV format? Default: false + * + * @return nothing + */ +template +void graph_print_distance2_color_histogram(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + // If graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries, + bool csv=false) +{ + typename KernelHandle::GraphColorDistance2HandleType *gch_d2 = handle->get_distance2_graph_coloring_handle(); + + Impl::GraphColorDistance2 + gc(num_rows, num_cols, row_entries.extent(0), row_map, row_entries, col_map, col_entries, gch_d2); + + if(csv) + { + gc.print_color_histogram_csv(); + } + else + { + gc.print_color_histogram(); + } +} + + + + } // namespace Impl } // namespace KokkosGraph From 46bceaa2cbc1cbc126fe3016d92f0c5368cf7584 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 13 Feb 2019 18:08:50 -0700 Subject: [PATCH 124/190] D2GC: Changed contact info in header block to me --- src/graph/KokkosGraph_Distance2Color.hpp | 2 +- src/graph/KokkosGraph_GraphColorDistance2Handle.hpp | 2 +- .../impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp | 2 +- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 4f879c5090..8b21dcb260 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -35,7 +35,7 @@ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// Questions? Contact William McLendon (wcmclen@sandia.gov) // // ************************************************************************ //@HEADER diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp index 67f61afb82..aca7293bad 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp @@ -35,7 +35,7 @@ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// Questions? Contact William McLendon (wcmclen@sandia.gov) // // ************************************************************************ //@HEADER diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index 208d670596..eaa725c079 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -35,7 +35,7 @@ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// Questions? Contact William McLendon (wcmclen@sandia.gov) // // ************************************************************************ //@HEADER diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 730b8c1728..b5d14a81a5 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -35,7 +35,7 @@ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// Questions? Contact William McLendon (wcmclen@sandia.gov) // // ************************************************************************ //@HEADER From b71151ceb306c0af542414d86ae2f4ca4f035454 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 14 Feb 2019 00:16:44 -0700 Subject: [PATCH 125/190] KokkosBatched- fix all --- ...Batched_Eigendecomposition_Serial_Impl.hpp | 18 +-- ...HessenbergQR_WithShift_Serial_Internal.hpp | 2 +- src/batched/KokkosBatched_InverseLU_Decl.hpp | 18 ++- ...ftEigenvectorFromSchur_Serial_Internal.hpp | 4 +- ...htEigenvectorFromSchur_Serial_Internal.hpp | 4 +- ...KokkosBatched_Schur2x2_Serial_Internal.hpp | 4 +- .../Test_Batched_SerialEigendecomposition.hpp | 3 +- .../batched/Test_Batched_SerialInverseLU.hpp | 2 +- .../batched/Test_Batched_SerialSolveLU.hpp | 48 +++---- .../batched/Test_Batched_TeamSolveLU.hpp | 126 +++++++++--------- 10 files changed, 118 insertions(+), 111 deletions(-) diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp index 1b86c6e2d8..4b010dd325 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp @@ -26,15 +26,15 @@ namespace KokkosBatched { const WViewType &W) { /// view checking const int m = A.extent(0); - assert(m == A.extent(1) && "Eigendecomposition: A is not square"); - assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); - assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); - assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); - assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); - assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); - assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); - assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); - assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); + assert(m == int(A.extent(1)) && "Eigendecomposition: A is not square"); + assert(m == int(er.extent(0)) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == int(ei.extent(0)) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == int(UL.extent(0)) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == int(UL.extent(1)) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == int(UR.extent(0)) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == int(UR.extent(1)) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(int(W.extent(0)) >= int(2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(int(W.stride(0)) == int(1) && "Eigendecomposition: Provided workspace is not contiguous"); /// static assert A,er,ei,UL,UR,W has the same value_type /// static assert all views have the same memory space diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index bd1c5d1ba0..8ceea5f3ac 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -25,7 +25,7 @@ namespace KokkosBatched { const ValueType shift, /* */ Kokkos::pair * GG, const bool request_schur) { typedef ValueType value_type; - typedef Kokkos::Details::ArithTraits ats; + //typedef Kokkos::Details::ArithTraits ats; const int hs = hs0+hs1; const value_type zero(0), one(1); diff --git a/src/batched/KokkosBatched_InverseLU_Decl.hpp b/src/batched/KokkosBatched_InverseLU_Decl.hpp index 0bb022a41c..c64799be5d 100644 --- a/src/batched/KokkosBatched_InverseLU_Decl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Decl.hpp @@ -17,11 +17,16 @@ namespace KokkosBatched { template struct SerialInverseLU { template + typename wViewType> KOKKOS_INLINE_FUNCTION static int invoke(const AViewType &A, - const WViewType &W) { + const wViewType &w) { + typedef typename wViewType::value_type value_type; + // workspace w is always 1D view; reinterpret it + Kokkos::View + W(w.data(), A.extent(0), A.extent(1)); + int r_val[3] = {}; r_val[0] = SerialCopy::invoke(A, W); r_val[1] = SerialSetIdentity::invoke(A); @@ -34,12 +39,17 @@ namespace KokkosBatched { typename ArgAlgo> struct TeamInverseLU { template + typename wViewType> KOKKOS_INLINE_FUNCTION static int invoke(const MemberType &member, const AViewType &A, - const WViewType &W) { + const wViewType &w) { + typedef typename wViewType::value_type value_type; + // workspace w is always 1D view; reinterpret it + Kokkos::View + W(w.data(), A.extent(0), A.extent(1)); + int r_val[3] = {}; r_val[0] = TeamCopy::invoke(member, A, W); r_val[1] = TeamSetIdentity::invoke(member, A); diff --git a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp index d0372d6834..0f6bdcd7ac 100644 --- a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp @@ -39,7 +39,7 @@ namespace KokkosBatched { const int * blks) { typedef ValueType value_type; typedef Kokkos::Details::ArithTraits ats; - typedef typename ats::mag_type mag_type; + //typedef typename ats::mag_type mag_type; typedef Kokkos::complex complex_type; const value_type zero(0), one(1); @@ -58,7 +58,7 @@ namespace KokkosBatched { S_part2x2.partWithATL(S, m, m, 0, 0); V_part2x1.partWithAT(V, m, 0); - const mag_type tol = ats::epsilon(); + //const mag_type tol = ats::epsilon(); int m_stl = 0; for (;m_stl<(m-1);) { /// part 2x2 into 3x3 diff --git a/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp b/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp index 8b679142d5..c2cf9cb0c1 100644 --- a/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_RightEigenvectorFromSchur_Serial_Internal.hpp @@ -39,7 +39,7 @@ namespace KokkosBatched { const int * blks) { typedef ValueType value_type; typedef Kokkos::Details::ArithTraits ats; - typedef typename ats::mag_type mag_type; + //typedef typename ats::mag_type mag_type; typedef Kokkos::complex complex_type; const value_type zero(0), one(1); @@ -59,7 +59,7 @@ namespace KokkosBatched { S_part2x2.partWithABR(S, m, m, 0, 0); V_part1x2.partWithAR(V, m, 0); - const mag_type tol = ats::epsilon(); + //const mag_type tol = ats::epsilon(); int m_stl = m; for (;m_stl>0;) { /// part 2x2 into 3x3 diff --git a/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp index 134bac0248..ef5747910b 100644 --- a/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp @@ -91,8 +91,8 @@ namespace KokkosBatched { const real_type sqrt_mult_alpha_offdiags = ats::sqrt(mult_alpha_offdiags); /// redefine the rotation matrix - const real_type sqrt_abs_alpha01 = ats::sqrt(ats::abs(*alpha01)); - const real_type sqrt_abs_alpha10 = ats::sqrt(ats::abs(*alpha10)); + //const real_type sqrt_abs_alpha01 = ats::sqrt(ats::abs(*alpha01)); + //const real_type sqrt_abs_alpha10 = ats::sqrt(ats::abs(*alpha10)); const real_type abs_sum_offidags = ats::abs((*alpha01)+(*alpha10)); const real_type c1 = ats::sqrt(ats::abs(*alpha01)/abs_sum_offidags); const real_type s1 = ats::sqrt(ats::abs(*alpha10)/abs_sum_offidags); diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp index ea993b5d6b..d42ca6506c 100644 --- a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp @@ -43,8 +43,7 @@ namespace Test { auto UR = Kokkos::subview(_UR, k, Kokkos::ALL(), Kokkos::ALL()); auto W = Kokkos::subview(_W, k, Kokkos::ALL()); - const int r_val = - SerialEigendecomposition::invoke(A, er, ei, UL, UR, W); + SerialEigendecomposition::invoke(A, er, ei, UL, UR, W); } inline diff --git a/unit_test/batched/Test_Batched_SerialInverseLU.hpp b/unit_test/batched/Test_Batched_SerialInverseLU.hpp index e3695c96c5..d8614405b8 100644 --- a/unit_test/batched/Test_Batched_SerialInverseLU.hpp +++ b/unit_test/batched/Test_Batched_SerialInverseLU.hpp @@ -158,7 +158,7 @@ namespace Test { /// randomized input testing views AViewType a0("a0", N, BlkSize, BlkSize); AViewType a1("a1", N, BlkSize, BlkSize); - WViewType w ("w", N, BlkSize*BlkSize ); + WViewType w ("w", N, BlkSize* BlkSize); AViewType c0("c0", N, BlkSize, BlkSize); Kokkos::Random_XorShift64_Pool random(13718); diff --git a/unit_test/batched/Test_Batched_SerialSolveLU.hpp b/unit_test/batched/Test_Batched_SerialSolveLU.hpp index 43b96a5dd7..5d4f74db5b 100644 --- a/unit_test/batched/Test_Batched_SerialSolveLU.hpp +++ b/unit_test/batched/Test_Batched_SerialSolveLU.hpp @@ -112,8 +112,8 @@ namespace Test { template + typename TransType, + typename AlgoTagType> struct Functor_TestBatchedSerialSolveLU { ViewType _a; ViewType _b; @@ -157,9 +157,9 @@ namespace Test { ViewType a0("a0", N, BlkSize, BlkSize); ViewType a1("a1", N, BlkSize, BlkSize); ViewType b ("b", N, BlkSize, 5 ); - ViewType x0("x0", N, BlkSize, 5 ); - ViewType a0_T("a0_T", N, BlkSize, BlkSize); - ViewType b_T ("b_T", N, BlkSize, 5 ); + ViewType x0("x0", N, BlkSize, 5 ); + //ViewType a0_T("a0_T", N, BlkSize, BlkSize); + //ViewType b_T ("b_T", N, BlkSize, 5 ); Kokkos::Random_XorShift64_Pool random(13718); Kokkos::fill_random(a0, random, value_type(1.0)); @@ -168,7 +168,7 @@ namespace Test { Kokkos::fence(); Kokkos::deep_copy(a1, a0); - Kokkos::deep_copy(a0_T, a0); + //Kokkos::deep_copy(a0_T, a0); value_type alpha = 1.0, beta = 0.0; typedef ParamTag param_tag_type; @@ -178,28 +178,28 @@ namespace Test { Functor_BatchedSerialLU(a1).run(); - Functor_TestBatchedSerialSolveLU(a1,b).run(); + Functor_TestBatchedSerialSolveLU(a1,b).run(); Kokkos::fence(); - //Transpose - typedef ParamTag param_tag_type_T; + // //Transpose + // typedef ParamTag param_tag_type_T; - Functor_BatchedSerialGemm(alpha, a0_T, x0, beta, b_T).run(); + // Functor_BatchedSerialGemm(alpha, a0_T, x0, beta, b_T).run(); - Functor_TestBatchedSerialSolveLU(a1,b_T).run(); + // Functor_TestBatchedSerialSolveLU(a1,b_T).run(); - Kokkos::fence(); + // Kokkos::fence(); /// for comparison send it to host typename ViewType::HostMirror x0_host = Kokkos::create_mirror_view(x0); typename ViewType::HostMirror b_host = Kokkos::create_mirror_view(b); - typename ViewType::HostMirror b_T_host = Kokkos::create_mirror_view(b_T); + //typename ViewType::HostMirror b_T_host = Kokkos::create_mirror_view(b_T); Kokkos::deep_copy(x0_host, x0); Kokkos::deep_copy(b_host, b); - Kokkos::deep_copy(b_T_host, b_T); + //Kokkos::deep_copy(b_T_host, b_T); /// check x0 = b ; this eps is about 10^-14 typedef typename ats::mag_type mag_type; @@ -216,16 +216,16 @@ namespace Test { EXPECT_NEAR_KK( diff/sum, 0.0, eps); /// check x0 = b_T ; this eps is about 10^-14 - mag_type sum_T(1), diff_T(0); + // mag_type sum_T(1), diff_T(0); - for (int k=0;k @@ -59,9 +59,9 @@ namespace Test { member.team_barrier(); TeamGemm:: + typename ParamTagType::transA, + typename ParamTagType::transB, + AlgoTagType>:: invoke(member, _alpha, aa, bb, _beta, cc); } @@ -81,32 +81,30 @@ namespace Test { Kokkos::Profiling::popRegion(); } }; - template struct Functor_BatchedTeamLU { ViewType _a; - + KOKKOS_INLINE_FUNCTION Functor_BatchedTeamLU(const ViewType &a) : _a(a) {} - + template KOKKOS_INLINE_FUNCTION void operator()(const MemberType &member) const { const int k = member.league_rank(); auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); - + if (member.team_rank() == 0) { for (int i=0;i(aa.extent(0));++i) aa(i,i) += 10.0; } member.team_barrier(); - + TeamLU::invoke(member, aa); } - inline void run() { typedef typename ViewType::value_type value_type; @@ -123,29 +121,28 @@ namespace Test { Kokkos::Profiling::popRegion(); } }; - template + typename TransType, + typename AlgoTagType> struct Functor_TestBatchedTeamSolveLU { ViewType _a; ViewType _b; - + KOKKOS_INLINE_FUNCTION Functor_TestBatchedTeamSolveLU(const ViewType &a, const ViewType &b) : _a(a), _b(b) {} - + template KOKKOS_INLINE_FUNCTION void operator()(const MemberType &member) const { const int k = member.league_rank(); auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - + TeamSolveLU::invoke(member, aa, bb); } - + inline void run() { typedef typename ViewType::value_type value_type; @@ -156,74 +153,74 @@ namespace Test { std::is_same >::value ? "::ComplexDouble" : "::UnknownValueType" ); std::string name = name_region + name_value_type; Kokkos::Profiling::pushRegion( name.c_str() ); - + const int league_size = _a.extent(0); Kokkos::TeamPolicy policy(league_size, Kokkos::AUTO); Kokkos::parallel_for((name+"::SolveLU").c_str(), policy, *this); Kokkos::Profiling::popRegion(); } }; - + template void impl_test_batched_solvelu(const int N, const int BlkSize) { typedef typename ViewType::value_type value_type; typedef Kokkos::Details::ArithTraits ats; - + /// randomized input testing views ViewType a0("a0", N, BlkSize, BlkSize); ViewType a1("a1", N, BlkSize, BlkSize); ViewType b ("b", N, BlkSize, 5 ); - ViewType x0("x0", N, BlkSize, 5 ); - ViewType a0_T("a0_T", N, BlkSize, BlkSize); - ViewType b_T ("b_T", N, BlkSize, 5 ); - + ViewType x0("x0", N, BlkSize, 5 ); + //ViewType a0_T("a0_T", N, BlkSize, BlkSize); + //ViewType b_T ("b_T", N, BlkSize, 5 ); + Kokkos::Random_XorShift64_Pool random(13718); Kokkos::fill_random(a0, random, value_type(1.0)); Kokkos::fill_random(x0, random, value_type(1.0)); - + Kokkos::fence(); - + Kokkos::deep_copy(a1, a0); - Kokkos::deep_copy(a0_T, a0); - + //Kokkos::deep_copy(a0_T, a0); + value_type alpha = 1.0, beta = 0.0; typedef ParamTag param_tag_type; - + Functor_BatchedTeamGemm(alpha, a0, x0, beta, b).run(); - + param_tag_type,AlgoTagType>(alpha, a0, x0, beta, b).run(); + Functor_BatchedTeamLU(a1).run(); - - Functor_TestBatchedTeamSolveLU(a1,b).run(); - - Kokkos::fence(); - - //Transpose - typedef ParamTag param_tag_type_T; - - Functor_BatchedTeamGemm(alpha, a0_T, x0, beta, b_T).run(); - - Functor_TestBatchedTeamSolveLU(a1,b_T).run(); - + + Functor_TestBatchedTeamSolveLU(a1,b).run(); + Kokkos::fence(); - + + // //Transpose + // typedef ParamTag param_tag_type_T; + + // Functor_BatchedTeamGemm(alpha, a0_T, x0, beta, b_T).run(); + + // Functor_TestBatchedTeamSolveLU(a1,b_T).run(); + + // Kokkos::fence(); + /// for comparison send it to host typename ViewType::HostMirror x0_host = Kokkos::create_mirror_view(x0); typename ViewType::HostMirror b_host = Kokkos::create_mirror_view(b); - typename ViewType::HostMirror b_T_host = Kokkos::create_mirror_view(b_T); - + //typename ViewType::HostMirror b_T_host = Kokkos::create_mirror_view(b_T); + Kokkos::deep_copy(x0_host, x0); Kokkos::deep_copy(b_host, b); - Kokkos::deep_copy(b_T_host, b_T); - + //Kokkos::deep_copy(b_T_host, b_T); + /// check x0 = b ; this eps is about 10^-14 typedef typename ats::mag_type mag_type; mag_type sum(1), diff(0); const mag_type eps = 1.0e3 * ats::epsilon(); - + for (int k=0;k From 6e30a1fc06038616c828f8c985f93f589e24d0df Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Feb 2019 11:05:01 -0700 Subject: [PATCH 126/190] D2GC: Making filenames consistent --- perf_test/graph/KokkosGraph_color.cpp | 3 +- perf_test/graph/KokkosGraph_color_d2.cpp | 8 +- src/common/KokkosKernels_Handle.hpp | 9 +- ...lor.hpp => KokkosGraph_Distance1Color.hpp} | 9 +- .../KokkosGraph_Distance1ColorHandle.hpp | 711 ++++++++++++++++++ src/graph/KokkosGraph_Distance2Color.hpp | 6 +- ...p => KokkosGraph_Distance2ColorHandle.hpp} | 7 + src/graph/KokkosGraph_GraphColorHandle.hpp | 670 +---------------- src/graph/KokkosGraph_graph_color.hpp | 12 +- ...raph_Distance2Color_MatrixSquared_impl.hpp | 4 +- .../impl/KokkosGraph_Distance2Color_impl.hpp | 48 +- .../impl/KokkosSparse_gauss_seidel_impl.hpp | 2 +- src/sparse/impl/KokkosSparse_spgemm_impl.hpp | 2 +- unit_test/graph/Test_Graph_graph_color.hpp | 2 +- .../Test_Graph_graph_color_deterministic.hpp | 2 +- .../Test_Graph_graph_color_distance2.hpp | 8 +- 16 files changed, 789 insertions(+), 714 deletions(-) rename src/graph/{KokkosGraph_GraphColor.hpp => KokkosGraph_Distance1Color.hpp} (97%) create mode 100644 src/graph/KokkosGraph_Distance1ColorHandle.hpp rename src/graph/{KokkosGraph_GraphColorDistance2Handle.hpp => KokkosGraph_Distance2ColorHandle.hpp} (98%) diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index 34e03dee9f..ada0009ebe 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -52,7 +52,8 @@ #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_MyCRSMatrix.hpp" #include "KokkosKernels_TestParameters.hpp" -#include "KokkosGraph_GraphColor.hpp" +// #include "KokkosGraph_Distance1Color.hpp" +#include "KokkosGraph_graph_color.hpp" diff --git a/perf_test/graph/KokkosGraph_color_d2.cpp b/perf_test/graph/KokkosGraph_color_d2.cpp index f8ae2b786b..223cd6a59f 100644 --- a/perf_test/graph/KokkosGraph_color_d2.cpp +++ b/perf_test/graph/KokkosGraph_color_d2.cpp @@ -597,7 +597,7 @@ void run_experiment(crsGraph_t crsGraph, Parameters params) } -template +template void experiment_driver(Parameters params) { using myExecSpace = exec_space; @@ -678,7 +678,7 @@ int main(int argc, char *argv[]) { if(!use_multi_mem) { - KokkosKernels::Experiment::experiment_driver(params); + KokkosKernels::Experiment::experiment_driver(params); } } #endif @@ -688,7 +688,7 @@ int main(int argc, char *argv[]) { if(!use_multi_mem) { - KokkosKernels::Experiment::experiment_driver(params); + KokkosKernels::Experiment::experiment_driver(params); } } #endif @@ -698,7 +698,7 @@ int main(int argc, char *argv[]) { if(!use_multi_mem) { - KokkosKernels::Experiment::experiment_driver(params); + KokkosKernels::Experiment::experiment_driver(params); } } #endif diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 14f7b00342..1125a62744 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -41,8 +41,8 @@ //@HEADER */ #include -#include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_GraphColorDistance2Handle.hpp" +#include "KokkosGraph_Distance1ColorHandle.hpp" +#include "KokkosGraph_Distance2ColorHandle.hpp" #include "KokkosSparse_gauss_seidel_handle.hpp" #include "KokkosSparse_spgemm_handle.hpp" #include "KokkosSparse_spadd_handle.hpp" @@ -407,7 +407,7 @@ class KokkosKernelsHandle // Distance-1 Graph Coloring GraphColoringHandleType *get_graph_coloring_handle(){ // (wcmclen): Should there be a check here to make sure we've created a GC handle before - // handing the pointer out to something? This is disabled for now because it + // handing the pointer out to something? This is disabled for now because it // gets thrown in tests run by spot check. Moving forward, we should consider // whether a "get the handle ptr, then allocate" vs. "only give out the handle ptr // if it actually exists" model. @@ -436,10 +436,13 @@ class KokkosKernelsHandle // Distance-2 Graph Coloring GraphColorDistance2HandleType *get_distance2_graph_coloring_handle() { + /* disabled for consistency with `get_graph_coloring_handle()`. See the comment there + for reasons. if(!this->is_owner_of_the_d2_gc_handle) { throw std::runtime_error("D2 graph coloring handle has not been created."); } + */ return this->gcHandle_d2; } void create_distance2_graph_coloring_handle(KokkosGraph::GraphColoringAlgorithmDistance2 coloring_type = KokkosGraph::COLORING_D2_DEFAULT) diff --git a/src/graph/KokkosGraph_GraphColor.hpp b/src/graph/KokkosGraph_Distance1Color.hpp similarity index 97% rename from src/graph/KokkosGraph_GraphColor.hpp rename to src/graph/KokkosGraph_Distance1Color.hpp index ed8bdc6fea..a3b2f7c839 100644 --- a/src/graph/KokkosGraph_GraphColor.hpp +++ b/src/graph/KokkosGraph_Distance1Color.hpp @@ -40,13 +40,13 @@ // ************************************************************************ //@HEADER */ -#ifndef _KOKKOS_GRAPH_COLOR_HPP -#define _KOKKOS_GRAPH_COLOR_HPP +#ifndef _KOKKOSGRAPH_DISTANCE1_COLOR_HPP +#define _KOKKOSGRAPH_DISTANCE1_COLOR_HPP #include +#include "KokkosGraph_Distance1ColorHandle.hpp" #include "KokkosGraph_Distance1Color_impl.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" #include "KokkosKernels_Utils.hpp" namespace KokkosGraph{ @@ -208,4 +208,5 @@ void d2_graph_color( } // end namespace Experimental } // end namespace KokkosGraph -#endif//_KOKKOS_GRAPH_COLOR_HPP +#endif // _KOKKOSGRAPH_DISTANCE1_COLOR_HPP + diff --git a/src/graph/KokkosGraph_Distance1ColorHandle.hpp b/src/graph/KokkosGraph_Distance1ColorHandle.hpp new file mode 100644 index 0000000000..9ad029a762 --- /dev/null +++ b/src/graph/KokkosGraph_Distance1ColorHandle.hpp @@ -0,0 +1,711 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#include +#include + +#include +#include +#include + +#ifndef _GRAPHCOLORHANDLE_HPP +#define _GRAPHCOLORHANDLE_HPP + +//#define VERBOSE +namespace KokkosGraph { + +enum ColoringAlgorithm { COLORING_DEFAULT, + COLORING_SERIAL, // Serial Greedy Coloring + COLORING_VB, // Vertex Based Coloring + COLORING_VBBIT, // Vertex Based Coloring with bit array + COLORING_VBCS, // Vertex Based Color Set + COLORING_VBD, // Vertex Based Deterministic Coloring + COLORING_VBDBIT, // Vertex Based Deterministic Coloring with bit array + COLORING_EB, // Edge Based Coloring + COLORING_SERIAL2, + COLORING_SPGEMM, + }; + +enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; + +enum ColoringType {Distance1, Distance2}; + +template +class GraphColoringHandle +{ + +public: + typedef ExecutionSpace HandleExecSpace; + typedef TemporaryMemorySpace HandleTempMemorySpace; + typedef PersistentMemorySpace HandlePersistentMemorySpace; + + + typedef typename std::remove_const::type size_type; + typedef const size_type const_size_type; + + typedef typename std::remove_const::type nnz_lno_t; + typedef const nnz_lno_t const_nnz_lno_t; + + typedef typename std::remove_const::type color_t; + typedef const color_t const_color_t; + + + + typedef typename Kokkos::View color_view_t; + + typedef typename color_view_t::array_layout color_view_array_layout; + typedef typename color_view_t::device_type color_view_device_t; + typedef typename color_view_t::memory_traits color_view_memory_traits; + typedef typename color_view_t::HostMirror color_host_view_t; //Host view type + + + typedef typename Kokkos::View size_type_temp_work_view_t; + typedef typename Kokkos::View size_type_persistent_work_view_t; + + typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; //Host view type + + typedef typename Kokkos::View nnz_lno_temp_work_view_t; + typedef typename Kokkos::View nnz_lno_persistent_work_view_t; + typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; //Host view type + + typedef Kokkos::TeamPolicy team_policy_t ; + typedef typename team_policy_t::member_type team_member_t ; + + typedef typename Kokkos::View non_const_1d_size_type_view_t; + +private: + + ColoringType GraphColoringType; + //Parameters + ColoringAlgorithm coloring_algorithm_type; //VB, VBBIT, VBCS, VBD or EB. + ConflictList conflict_list_type; // whether to use a conflict list or not, and + // if using it wheter to create it with atomic or parallel prefix sum. + + double min_reduction_for_conflictlist; + //if used pps is selected to create conflict list, what min percantage should be the vertex list + //be reduced, to create the new vertexlist. If it is reduced less than this percantage, use the + //previous array. + + int min_elements_for_conflictlist; + //minimum number of elements to create a new conflict list. + //if current conflict list size is smaller than this number, + //than we do not need to create a new conflict list. + + bool serial_conflict_resolution;//perform parallel greedy coloring once, then resolve conflict serially. + bool tictoc; //print time at every step + + bool vb_edge_filtering; //whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. + + int vb_chunk_size; //the (minimum) size of the consecutive works that a thread will be assigned to. + int max_number_of_iterations; //maximum allowed number of phases + + int eb_num_initial_colors; //the number of colors to assign at the beginning of the edge-based algorithm + + //STATISTICS + double overall_coloring_time; //the overall time that it took to color the graph. In the case of the iterative calls. + double overall_coloring_time_phase1; // + double overall_coloring_time_phase2; // + double overall_coloring_time_phase3; // Some timer accumulators for internal phases. + double overall_coloring_time_phase4; // + double overall_coloring_time_phase5; // + double coloring_time; //the time that it took to color the graph + + int num_phases; // + + + size_type size_of_edge_list; + nnz_lno_persistent_work_view_t lower_triangle_src; + nnz_lno_persistent_work_view_t lower_triangle_dst; + + color_view_t vertex_colors; + bool is_coloring_called_before; + nnz_lno_t num_colors; + + + public: + + + /** + * \brief Default constructor. + */ + GraphColoringHandle(): + GraphColoringType(Distance1), + coloring_algorithm_type(COLORING_DEFAULT), + conflict_list_type(COLORING_ATOMIC), + min_reduction_for_conflictlist(0.35), + min_elements_for_conflictlist(1000 /*5000*/), + serial_conflict_resolution(false), + tictoc(false), + vb_edge_filtering(false), + vb_chunk_size(8), + max_number_of_iterations(200), + eb_num_initial_colors(1), + overall_coloring_time(0), + overall_coloring_time_phase1(0), + overall_coloring_time_phase2(0), + overall_coloring_time_phase3(0), + overall_coloring_time_phase4(0), + overall_coloring_time_phase5(0), + coloring_time(0), + num_phases(0), size_of_edge_list(0), lower_triangle_src(), lower_triangle_dst(), + vertex_colors(), is_coloring_called_before(false), num_colors(0) + { + this->choose_default_algorithm(); + this->set_defaults(this->coloring_algorithm_type); + } + + /** \brief Sets the graph coloring type. Whether it is distance-1 or distance-2 coloring. + * \param col_type: Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be + * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 + */ + void set_coloring_type(const ColoringType &col_type){ + this->GraphColoringType = col_type; + } + + /** \brief Gets the graph coloring type. Whether it is distance-1 or distance-2 coloring. + * returns Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be + * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 + */ + ColoringType get_coloring_type(){ + return this->GraphColoringType; + } + + + /** \brief Changes the graph coloring algorithm. + * \param col_algo: Coloring algorithm: one of COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB + * \param set_default_parameters: whether or not to reset the default parameters for the given algorithm. + */ + void set_algorithm(const ColoringAlgorithm &col_algo, bool set_default_parameters = true){ + if (col_algo == COLORING_DEFAULT){ + this->choose_default_algorithm(); + } + else { + this->coloring_algorithm_type = col_algo; + } + if (set_default_parameters){ + this->set_defaults(this->coloring_algorithm_type); + } + } + + + /** \brief Chooses best algorithm based on the execution space. COLORING_EB if cuda, COLORING_VB otherwise. + */ + void choose_default_algorithm() + { +#if defined( KOKKOS_ENABLE_SERIAL ) + if (Kokkos::Impl::is_same< Kokkos::Serial , ExecutionSpace >::value){ + this->coloring_algorithm_type = COLORING_SERIAL; +#ifdef VERBOSE + std::cout << "Serial Execution Space, Default Algorithm: COLORING_VB" << std::endl; +#endif + } +#endif + +#if defined( KOKKOS_ENABLE_THREADS ) + if (Kokkos::Impl::is_same< Kokkos::Threads , ExecutionSpace >::value){ + this->coloring_algorithm_type = COLORING_VB; +#ifdef VERBOSE + std::cout << "PTHREAD Execution Space, Default Algorithm: COLORING_VB" << std::endl; +#endif + } +#endif + +#if defined( KOKKOS_ENABLE_OPENMP ) + if (Kokkos::Impl::is_same< Kokkos::OpenMP, ExecutionSpace >::value){ + this->coloring_algorithm_type = COLORING_VB; +#ifdef VERBOSE + std::cout << "OpenMP Execution Space, Default Algorithm: COLORING_VB" << std::endl; +#endif + } +#endif + +#if defined( KOKKOS_ENABLE_CUDA ) + if (Kokkos::Impl::is_same::value){ + this->coloring_algorithm_type = COLORING_EB; +#ifdef VERBOSE + std::cout << "Cuda Execution Space, Default Algorithm: COLORING_VB" << std::endl; +#endif + } +#endif + +#if defined( KOKKOS_ENABLE_QTHREAD) + if (Kokkos::Impl::is_same< Kokkos::Qthread, ExecutionSpace >::value){ + this->coloring_algorithm_type = COLORING_VB; +#ifdef VERBOSE + std::cout << "Qthread Execution Space, Default Algorithm: COLORING_VB" << std::endl; +#endif + } +#endif + } + + template + struct CountLowerTriangle{ + nnz_lno_t nv; + v1 xadj; + v2 adj; + v3 lower_xadj_counts; + + CountLowerTriangle( + nnz_lno_t nv_, + v1 xadj_, + v2 adj_, + v3 lower_xadj_counts_ + ): nv(nv_), + xadj(xadj_), adj(adj_), + lower_xadj_counts(lower_xadj_counts_){} + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t &i, size_type &new_num_edge) const { + size_type xadj_begin = xadj(i); + size_type xadj_end = xadj(i + 1); + + size_type new_edge_count = 0; + for (size_type j = xadj_begin; j < xadj_end; ++j){ + nnz_lno_t n = adj(j); + if (i < n && n < nv){ + new_edge_count += 1; + } + } + lower_xadj_counts(i + 1) = new_edge_count; + new_num_edge += new_edge_count; + } + }; + + + + template + struct CountLowerTriangleTeam{ + + nnz_lno_t nv; + v1 xadj; + v2 adj; + v3 lower_xadj_counts; + + CountLowerTriangleTeam( + nnz_lno_t nv_, + v1 xadj_, + v2 adj_, + v3 lower_xadj_counts_ + ): nv(nv_), + xadj(xadj_), adj(adj_), + lower_xadj_counts(lower_xadj_counts_){} + + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t & teamMember/*, row_lno_t &new_num_edge*/) const { + + + nnz_lno_t ii = teamMember.league_rank() * teamMember.team_size()+ teamMember.team_rank(); + if (ii >= nv) { + return; + } + + size_type xadj_begin = xadj(ii); + size_type xadj_end = xadj(ii + 1); + + size_type new_edge_count = 0; + + + Kokkos::parallel_reduce( + Kokkos::ThreadVectorRange(teamMember, xadj_end - xadj_begin), + [&] (size_type i, size_type &numEdges) { + + size_type adjind = i + xadj_begin; + nnz_lno_t n = adj[adjind]; + if (ii < n && n < nv){ + numEdges += 1; + } + }, new_edge_count); + + Kokkos::single(Kokkos::PerThread(teamMember),[=] () { + lower_xadj_counts(ii + 1) = new_edge_count; + }); + } + }; + + + + template + struct FillLowerTriangleTeam{ + nnz_lno_t nv; + v1 xadj; + v2 adj; + v3 lower_xadj_counts; + v4 lower_srcs; + v4 lower_dsts; + + FillLowerTriangleTeam( + nnz_lno_t nv_, + v1 xadj_, + v2 adj_, + v3 lower_xadj_counts_, + v4 lower_srcs_, + v4 lower_dsts_ + ): nv(nv_), + xadj(xadj_), adj(adj_), + lower_xadj_counts(lower_xadj_counts_), + lower_srcs(lower_srcs_), lower_dsts(lower_dsts_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()(const team_member_t & teamMember) const { + typedef typename std::remove_reference< decltype( lower_xadj_counts(0) ) >::type atomic_incr_type; + + nnz_lno_t ii = teamMember.league_rank() * teamMember.team_size()+ teamMember.team_rank(); + if (ii >= nv) { + return; + } + + size_type xadj_begin = xadj(ii); + size_type xadj_end = xadj(ii + 1); + + Kokkos::parallel_for( + Kokkos::ThreadVectorRange(teamMember, xadj_end - xadj_begin), + [&] (size_type i) { + + size_type adjind = i + xadj_begin; + nnz_lno_t n = adj[adjind]; + if (ii < n && n < nv){ + size_type position = + Kokkos::atomic_fetch_add( &(lower_xadj_counts(ii)), atomic_incr_type(1)); + lower_srcs(position) = ii; + lower_dsts(position) = n; + } + }); + } + }; + + + + template + struct FillLowerTriangle{ + nnz_lno_t nv; + v1 xadj; + v2 adj; + v3 lower_xadj_counts; + v4 lower_srcs; + v4 lower_dsts; + + FillLowerTriangle( + nnz_lno_t nv_, + v1 xadj_, + v2 adj_, + v3 lower_xadj_counts_, + v4 lower_srcs_, + v4 lower_dsts_ + ): nv(nv_), + xadj(xadj_), adj(adj_), + lower_xadj_counts(lower_xadj_counts_), + lower_srcs(lower_srcs_), lower_dsts(lower_dsts_) {} + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t &i) const{ + + size_type xadj_begin = xadj[i]; + size_type xadj_end = xadj[i + 1]; + + for (size_type j = xadj_begin; j < xadj_end; ++j){ + nnz_lno_t n = adj(j); + if (i < n && n < nv){ + size_type position = lower_xadj_counts(i)++; + lower_srcs(position) = i; + lower_dsts(position) = n; + } + } + } + }; + + + + template + void symmetrize_and_calculate_lower_diagonal_edge_list( + nnz_lno_t nv, + row_index_view_type xadj, nonzero_view_type adj){ + + KokkosKernels::Impl::symmetrize_and_get_lower_diagonal_edge_list + + ( + nv, + xadj, + adj, + lower_triangle_src, + lower_triangle_dst); + + size_of_edge_list = lower_triangle_src.extent(0); + + } + + + + template + void get_lower_diagonal_edge_list( + nnz_lno_t nv, size_type ne, + row_index_view_type xadj, nonzero_view_type adj, + size_type &num_out_edges, + nnz_lno_persistent_work_view_t &src, + nnz_lno_persistent_work_view_t &dst){ + + if (size_of_edge_list > 0){ + num_out_edges = size_of_edge_list; + //src = Kokkos::View (this->lower_triangle_src); + //dst = Kokkos::View (this->lower_triangle_dst); + src = (this->lower_triangle_src); + dst = (this->lower_triangle_dst); + } + else { + + size_type_temp_work_view_t lower_count("LowerXADJ", nv + 1); + size_type new_num_edge = 0; + typedef Kokkos::RangePolicy my_exec_space; + + if ( 0 +#if defined( KOKKOS_ENABLE_CUDA ) + || Kokkos::Impl::is_same::value +#endif + ) + { + + + int teamSizeMax = 0; + int vector_size = 0; + + CountLowerTriangleTeam clt (nv, xadj, adj, lower_count); +#ifdef KOKKOS_ENABLE_DEPRECATED_CODE + int max_allowed_team_size = team_policy_t::team_size_max(clt); + KokkosKernels::Impl::get_suggested_vector_team_size( + max_allowed_team_size, + vector_size, + teamSizeMax, + nv, ne); +#else + KokkosKernels::Impl::get_suggested_vector_size( + vector_size, + nv, ne); + + team_policy_t tmp_policy(nv, Kokkos::AUTO, vector_size); + int max_allowed_team_size = tmp_policy.team_size_max( clt, Kokkos::ParallelForTag() ); + + KokkosKernels::Impl::get_suggested_team_size( + max_allowed_team_size, + vector_size, + teamSizeMax); +#endif + + Kokkos::parallel_for("KokkosGraph::CountLowerTriangleTeam", + team_policy_t(nv / teamSizeMax + 1 , teamSizeMax, vector_size), + clt//, new_num_edge + ); + + KokkosKernels::Impl::inclusive_parallel_prefix_sum + (nv+1, lower_count); + //Kokkos::parallel_scan (my_exec_space(0, nv + 1), PPS(lower_count)); + HandleExecSpace::fence(); + auto lower_total_count = Kokkos::subview(lower_count, nv); + auto hlower = Kokkos::create_mirror_view (lower_total_count); + Kokkos::deep_copy (hlower, lower_total_count); + + new_num_edge = hlower(); + nnz_lno_persistent_work_view_t half_src (Kokkos::ViewAllocateWithoutInitializing("HALF SRC"),new_num_edge); + nnz_lno_persistent_work_view_t half_dst (Kokkos::ViewAllocateWithoutInitializing("HALF DST"),new_num_edge); + Kokkos::parallel_for("KokkosGraph::FillLowerTriangleTeam", + team_policy_t(nv / teamSizeMax + 1 , teamSizeMax, vector_size), + FillLowerTriangleTeam + (nv, xadj, adj, lower_count, half_src, half_dst)); + + src = lower_triangle_src = half_src; + dst = lower_triangle_dst = half_dst; + num_out_edges = size_of_edge_list = new_num_edge; + } + else { + if (nv > 0) { + Kokkos::parallel_reduce("KokkosGraph::CountLowerTriangleTeam",my_exec_space(0,nv), + CountLowerTriangle (nv, xadj, adj, lower_count), new_num_edge); + } + + //Kokkos::parallel_scan (my_exec_space(0, nv + 1), PPS(lower_count)); + + KokkosKernels::Impl::inclusive_parallel_prefix_sum + (nv+1, lower_count); + nnz_lno_persistent_work_view_t half_src (Kokkos::ViewAllocateWithoutInitializing("HALF SRC"),new_num_edge); + nnz_lno_persistent_work_view_t half_dst (Kokkos::ViewAllocateWithoutInitializing("HALF DST"),new_num_edge); + + Kokkos::parallel_for("KokkosGraph::FillLowerTriangleTeam",my_exec_space(0,nv), FillLowerTriangle + (nv, xadj, adj, lower_count, half_src, half_dst)); + + src = lower_triangle_src = half_src; + dst = lower_triangle_dst = half_dst; + num_out_edges = size_of_edge_list = new_num_edge; + } + } + } + + + + struct ReduceMaxFunctor{ + color_view_t colors; + ReduceMaxFunctor(color_view_t cat):colors(cat){} + + KOKKOS_INLINE_FUNCTION + void operator()(const nnz_lno_t &i, color_t & color_max) const { + if (color_max < colors(i) ) color_max = colors(i); + } + + KOKKOS_INLINE_FUNCTION + void join (volatile color_t& dst , const volatile color_t& src) const { // max -plus semiring equivalent of "plus" + if (dst < src) { + dst = src; + } + } + + KOKKOS_INLINE_FUNCTION + void init (color_t& dst) const { + dst = 0; + } + }; + + + nnz_lno_t get_num_colors(){ + if (num_colors == 0){ + typedef typename Kokkos::RangePolicy my_exec_space; + Kokkos::parallel_reduce("KokkosKernels::FindMax", my_exec_space(0, vertex_colors.extent(0)), + ReduceMaxFunctor(vertex_colors) ,num_colors); + } + return num_colors; + } + + + + /** \brief Sets Default Parameter settings for the given algorithm. + */ + void set_defaults (const ColoringAlgorithm &col_algo){ + switch (col_algo){ + case COLORING_VB: + case COLORING_VBBIT: + case COLORING_VBCS: + case COLORING_VBD: + case COLORING_VBDBIT: + case COLORING_SERIAL: + this->conflict_list_type = COLORING_ATOMIC; + this->min_reduction_for_conflictlist = 0.35; + this->min_elements_for_conflictlist = 1000; + this->serial_conflict_resolution = false; + this->tictoc = false; + this->vb_edge_filtering = false; + this->vb_chunk_size = 8; + this->max_number_of_iterations = 200; + this->eb_num_initial_colors = 1; + break; + case COLORING_EB: + this->conflict_list_type = COLORING_PPS; + this->min_reduction_for_conflictlist = 0.35; + this->min_elements_for_conflictlist = 5000; + this->serial_conflict_resolution = false; + this->tictoc = false; + this->vb_edge_filtering = false; + this->vb_chunk_size = 8; + this->max_number_of_iterations = 20000; + this->eb_num_initial_colors = 1; + break; + default: + throw std::runtime_error ("Unknown Coloring Algorithm\n"); + //break; + } + } + + + virtual ~GraphColoringHandle(){}; + + //getters + ColoringAlgorithm get_coloring_algo_type() const {return this->coloring_algorithm_type;} + ConflictList get_conflict_list_type() const {return this->conflict_list_type;} + double get_min_reduction_for_conflictlist() const{return this->min_reduction_for_conflictlist;} + int get_min_elements_for_conflictlist() const{ return this->min_elements_for_conflictlist;} + bool get_serial_conflict_resolution() const{return this->serial_conflict_resolution;} + bool get_tictoc() const{return this->tictoc;} + bool get_vb_edge_filtering() const{return this->vb_edge_filtering;} + int get_vb_chunk_size() const{return this->vb_chunk_size;} + int get_max_number_of_iterations() const{return this->max_number_of_iterations;} + int get_eb_num_initial_colors() const{return this->eb_num_initial_colors;} + + double get_overall_coloring_time() const { return this->overall_coloring_time;} + double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } + double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } + double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } + double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } + double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } + double get_coloring_time() const { return this->coloring_time;} + int get_num_phases() const { return this->num_phases;} + color_view_t get_vertex_colors() const {return this->vertex_colors;} + bool is_coloring_called() const {return this->is_coloring_called_before;} + //setters + void set_coloring_algo_type(const ColoringAlgorithm &col_algo){this->coloring_algorithm_type = col_algo;} + void set_conflict_list_type(const ConflictList &cl){this->conflict_list_type = cl;} + void set_min_reduction_for_conflictlist(const double &min_reduction){this->min_reduction_for_conflictlist = min_reduction;} + void set_min_elements_for_conflictlist(const int &min_elements){ this->min_elements_for_conflictlist = min_elements;} + void set_serial_conflict_resolution(const bool &use_serial_conflist_resolution){this->serial_conflict_resolution = use_serial_conflist_resolution;} + void set_tictoc(const bool use_tictoc){this->tictoc = use_tictoc;} + void set_vb_edge_filtering(const bool &use_vb_edge_filtering){this->vb_edge_filtering = use_vb_edge_filtering;} + void set_vb_chunk_size(const int &chunksize){this->vb_chunk_size = chunksize;} + void set_max_number_of_iterations(const int &max_phases){this->max_number_of_iterations = max_phases;} + void set_eb_num_initial_colors(const int &num_initial_colors){this->eb_num_initial_colors = num_initial_colors;} + void add_to_overall_coloring_time(const double &coloring_time_){this->overall_coloring_time += coloring_time_;} + void add_to_overall_coloring_time_phase1(const double &coloring_time_){this->overall_coloring_time_phase1 += coloring_time_;} + void add_to_overall_coloring_time_phase2(const double &coloring_time_){this->overall_coloring_time_phase2 += coloring_time_;} + void add_to_overall_coloring_time_phase3(const double &coloring_time_){this->overall_coloring_time_phase3 += coloring_time_;} + void add_to_overall_coloring_time_phase4(const double &coloring_time_){this->overall_coloring_time_phase4 += coloring_time_;} + void add_to_overall_coloring_time_phase5(const double &coloring_time_){this->overall_coloring_time_phase5 += coloring_time_;} + void set_coloring_time(const double &coloring_time_){this->coloring_time = coloring_time_;} + void set_num_phases(const double &num_phases_){this->num_phases = num_phases_;} + void set_vertex_colors( const color_view_t vertex_colors_){ + this->vertex_colors = vertex_colors_; + this->is_coloring_called_before = true; + this->num_colors = 0; + } + +}; + +} // namespace KokkosGraph + +#endif // _GRAPHCOLORHANDLE_HPP diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 8b21dcb260..93c79bf5e8 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -43,9 +43,9 @@ #ifndef _KOKKOS_GRAPH_COLORDISTANCE2_HPP #define _KOKKOS_GRAPH_COLORDISTANCE2_HPP -#include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_GraphColorDistance2Handle.hpp" -#include "KokkosGraph_Distance1Color_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? +#include "KokkosGraph_Distance1ColorHandle.hpp" +#include "KokkosGraph_Distance2ColorHandle.hpp" +#include "KokkosGraph_Distance1Color_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? (WCMCLEN-SCAFFOLDING) #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" diff --git a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp b/src/graph/KokkosGraph_Distance2ColorHandle.hpp similarity index 98% rename from src/graph/KokkosGraph_GraphColorDistance2Handle.hpp rename to src/graph/KokkosGraph_Distance2ColorHandle.hpp index aca7293bad..b7fdc685b2 100644 --- a/src/graph/KokkosGraph_GraphColorDistance2Handle.hpp +++ b/src/graph/KokkosGraph_Distance2ColorHandle.hpp @@ -157,6 +157,13 @@ class GraphColorDistance2Handle { this->choose_default_algorithm(); this->set_defaults(this->coloring_algorithm_type); + + // Throw an error if PersistentMemSpace != TempMemSpace since we don't support them being different (for now). + if(!Kokkos::Impl::is_same::value) + { + std::string message = "Distance-2 Graph Coloring Handle does not currently support different mem spaces"; + Kokkos::Impl::throw_runtime_exception(message); + } } diff --git a/src/graph/KokkosGraph_GraphColorHandle.hpp b/src/graph/KokkosGraph_GraphColorHandle.hpp index 9ad029a762..307d83a4d4 100644 --- a/src/graph/KokkosGraph_GraphColorHandle.hpp +++ b/src/graph/KokkosGraph_GraphColorHandle.hpp @@ -40,672 +40,20 @@ // ************************************************************************ //@HEADER */ -#include -#include -#include -#include -#include -#ifndef _GRAPHCOLORHANDLE_HPP -#define _GRAPHCOLORHANDLE_HPP - -//#define VERBOSE -namespace KokkosGraph { - -enum ColoringAlgorithm { COLORING_DEFAULT, - COLORING_SERIAL, // Serial Greedy Coloring - COLORING_VB, // Vertex Based Coloring - COLORING_VBBIT, // Vertex Based Coloring with bit array - COLORING_VBCS, // Vertex Based Color Set - COLORING_VBD, // Vertex Based Deterministic Coloring - COLORING_VBDBIT, // Vertex Based Deterministic Coloring with bit array - COLORING_EB, // Edge Based Coloring - COLORING_SERIAL2, - COLORING_SPGEMM, - }; - -enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; - -enum ColoringType {Distance1, Distance2}; - -template -class GraphColoringHandle -{ - -public: - typedef ExecutionSpace HandleExecSpace; - typedef TemporaryMemorySpace HandleTempMemorySpace; - typedef PersistentMemorySpace HandlePersistentMemorySpace; - - - typedef typename std::remove_const::type size_type; - typedef const size_type const_size_type; - - typedef typename std::remove_const::type nnz_lno_t; - typedef const nnz_lno_t const_nnz_lno_t; - - typedef typename std::remove_const::type color_t; - typedef const color_t const_color_t; - - - - typedef typename Kokkos::View color_view_t; - - typedef typename color_view_t::array_layout color_view_array_layout; - typedef typename color_view_t::device_type color_view_device_t; - typedef typename color_view_t::memory_traits color_view_memory_traits; - typedef typename color_view_t::HostMirror color_host_view_t; //Host view type - - - typedef typename Kokkos::View size_type_temp_work_view_t; - typedef typename Kokkos::View size_type_persistent_work_view_t; - - typedef typename size_type_persistent_work_view_t::HostMirror size_type_persistent_work_host_view_t; //Host view type - - typedef typename Kokkos::View nnz_lno_temp_work_view_t; - typedef typename Kokkos::View nnz_lno_persistent_work_view_t; - typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; //Host view type - - typedef Kokkos::TeamPolicy team_policy_t ; - typedef typename team_policy_t::member_type team_member_t ; - - typedef typename Kokkos::View non_const_1d_size_type_view_t; - -private: - - ColoringType GraphColoringType; - //Parameters - ColoringAlgorithm coloring_algorithm_type; //VB, VBBIT, VBCS, VBD or EB. - ConflictList conflict_list_type; // whether to use a conflict list or not, and - // if using it wheter to create it with atomic or parallel prefix sum. - - double min_reduction_for_conflictlist; - //if used pps is selected to create conflict list, what min percantage should be the vertex list - //be reduced, to create the new vertexlist. If it is reduced less than this percantage, use the - //previous array. - - int min_elements_for_conflictlist; - //minimum number of elements to create a new conflict list. - //if current conflict list size is smaller than this number, - //than we do not need to create a new conflict list. - - bool serial_conflict_resolution;//perform parallel greedy coloring once, then resolve conflict serially. - bool tictoc; //print time at every step - - bool vb_edge_filtering; //whether to do edge filtering or not in vertex based algorithms. Swaps on the ad error. - - int vb_chunk_size; //the (minimum) size of the consecutive works that a thread will be assigned to. - int max_number_of_iterations; //maximum allowed number of phases - - int eb_num_initial_colors; //the number of colors to assign at the beginning of the edge-based algorithm - - //STATISTICS - double overall_coloring_time; //the overall time that it took to color the graph. In the case of the iterative calls. - double overall_coloring_time_phase1; // - double overall_coloring_time_phase2; // - double overall_coloring_time_phase3; // Some timer accumulators for internal phases. - double overall_coloring_time_phase4; // - double overall_coloring_time_phase5; // - double coloring_time; //the time that it took to color the graph - - int num_phases; // - - - size_type size_of_edge_list; - nnz_lno_persistent_work_view_t lower_triangle_src; - nnz_lno_persistent_work_view_t lower_triangle_dst; - - color_view_t vertex_colors; - bool is_coloring_called_before; - nnz_lno_t num_colors; - - - public: - - - /** - * \brief Default constructor. - */ - GraphColoringHandle(): - GraphColoringType(Distance1), - coloring_algorithm_type(COLORING_DEFAULT), - conflict_list_type(COLORING_ATOMIC), - min_reduction_for_conflictlist(0.35), - min_elements_for_conflictlist(1000 /*5000*/), - serial_conflict_resolution(false), - tictoc(false), - vb_edge_filtering(false), - vb_chunk_size(8), - max_number_of_iterations(200), - eb_num_initial_colors(1), - overall_coloring_time(0), - overall_coloring_time_phase1(0), - overall_coloring_time_phase2(0), - overall_coloring_time_phase3(0), - overall_coloring_time_phase4(0), - overall_coloring_time_phase5(0), - coloring_time(0), - num_phases(0), size_of_edge_list(0), lower_triangle_src(), lower_triangle_dst(), - vertex_colors(), is_coloring_called_before(false), num_colors(0) - { - this->choose_default_algorithm(); - this->set_defaults(this->coloring_algorithm_type); - } - - /** \brief Sets the graph coloring type. Whether it is distance-1 or distance-2 coloring. - * \param col_type: Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be - * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 - */ - void set_coloring_type(const ColoringType &col_type){ - this->GraphColoringType = col_type; - } - - /** \brief Gets the graph coloring type. Whether it is distance-1 or distance-2 coloring. - * returns Coloring Type: KokkosKernels::Experimental::Graph::ColoringType which can be - * either KokkosKernels::Experimental::Graph::Distance1 or KokkosKernels::Experimental::Graph::Distance2 - */ - ColoringType get_coloring_type(){ - return this->GraphColoringType; - } - - - /** \brief Changes the graph coloring algorithm. - * \param col_algo: Coloring algorithm: one of COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB - * \param set_default_parameters: whether or not to reset the default parameters for the given algorithm. - */ - void set_algorithm(const ColoringAlgorithm &col_algo, bool set_default_parameters = true){ - if (col_algo == COLORING_DEFAULT){ - this->choose_default_algorithm(); - } - else { - this->coloring_algorithm_type = col_algo; - } - if (set_default_parameters){ - this->set_defaults(this->coloring_algorithm_type); - } - } - - - /** \brief Chooses best algorithm based on the execution space. COLORING_EB if cuda, COLORING_VB otherwise. - */ - void choose_default_algorithm() - { -#if defined( KOKKOS_ENABLE_SERIAL ) - if (Kokkos::Impl::is_same< Kokkos::Serial , ExecutionSpace >::value){ - this->coloring_algorithm_type = COLORING_SERIAL; -#ifdef VERBOSE - std::cout << "Serial Execution Space, Default Algorithm: COLORING_VB" << std::endl; -#endif - } -#endif - -#if defined( KOKKOS_ENABLE_THREADS ) - if (Kokkos::Impl::is_same< Kokkos::Threads , ExecutionSpace >::value){ - this->coloring_algorithm_type = COLORING_VB; -#ifdef VERBOSE - std::cout << "PTHREAD Execution Space, Default Algorithm: COLORING_VB" << std::endl; -#endif - } -#endif - -#if defined( KOKKOS_ENABLE_OPENMP ) - if (Kokkos::Impl::is_same< Kokkos::OpenMP, ExecutionSpace >::value){ - this->coloring_algorithm_type = COLORING_VB; -#ifdef VERBOSE - std::cout << "OpenMP Execution Space, Default Algorithm: COLORING_VB" << std::endl; -#endif - } -#endif - -#if defined( KOKKOS_ENABLE_CUDA ) - if (Kokkos::Impl::is_same::value){ - this->coloring_algorithm_type = COLORING_EB; -#ifdef VERBOSE - std::cout << "Cuda Execution Space, Default Algorithm: COLORING_VB" << std::endl; -#endif - } -#endif - -#if defined( KOKKOS_ENABLE_QTHREAD) - if (Kokkos::Impl::is_same< Kokkos::Qthread, ExecutionSpace >::value){ - this->coloring_algorithm_type = COLORING_VB; -#ifdef VERBOSE - std::cout << "Qthread Execution Space, Default Algorithm: COLORING_VB" << std::endl; -#endif - } -#endif - } - - template - struct CountLowerTriangle{ - nnz_lno_t nv; - v1 xadj; - v2 adj; - v3 lower_xadj_counts; - - CountLowerTriangle( - nnz_lno_t nv_, - v1 xadj_, - v2 adj_, - v3 lower_xadj_counts_ - ): nv(nv_), - xadj(xadj_), adj(adj_), - lower_xadj_counts(lower_xadj_counts_){} - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t &i, size_type &new_num_edge) const { - size_type xadj_begin = xadj(i); - size_type xadj_end = xadj(i + 1); - - size_type new_edge_count = 0; - for (size_type j = xadj_begin; j < xadj_end; ++j){ - nnz_lno_t n = adj(j); - if (i < n && n < nv){ - new_edge_count += 1; - } - } - lower_xadj_counts(i + 1) = new_edge_count; - new_num_edge += new_edge_count; - } - }; - - - - template - struct CountLowerTriangleTeam{ - - nnz_lno_t nv; - v1 xadj; - v2 adj; - v3 lower_xadj_counts; - - CountLowerTriangleTeam( - nnz_lno_t nv_, - v1 xadj_, - v2 adj_, - v3 lower_xadj_counts_ - ): nv(nv_), - xadj(xadj_), adj(adj_), - lower_xadj_counts(lower_xadj_counts_){} - - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t & teamMember/*, row_lno_t &new_num_edge*/) const { - - - nnz_lno_t ii = teamMember.league_rank() * teamMember.team_size()+ teamMember.team_rank(); - if (ii >= nv) { - return; - } - - size_type xadj_begin = xadj(ii); - size_type xadj_end = xadj(ii + 1); - - size_type new_edge_count = 0; - - - Kokkos::parallel_reduce( - Kokkos::ThreadVectorRange(teamMember, xadj_end - xadj_begin), - [&] (size_type i, size_type &numEdges) { - - size_type adjind = i + xadj_begin; - nnz_lno_t n = adj[adjind]; - if (ii < n && n < nv){ - numEdges += 1; - } - }, new_edge_count); - - Kokkos::single(Kokkos::PerThread(teamMember),[=] () { - lower_xadj_counts(ii + 1) = new_edge_count; - }); - } - }; - - - - template - struct FillLowerTriangleTeam{ - nnz_lno_t nv; - v1 xadj; - v2 adj; - v3 lower_xadj_counts; - v4 lower_srcs; - v4 lower_dsts; - - FillLowerTriangleTeam( - nnz_lno_t nv_, - v1 xadj_, - v2 adj_, - v3 lower_xadj_counts_, - v4 lower_srcs_, - v4 lower_dsts_ - ): nv(nv_), - xadj(xadj_), adj(adj_), - lower_xadj_counts(lower_xadj_counts_), - lower_srcs(lower_srcs_), lower_dsts(lower_dsts_) {} - - - KOKKOS_INLINE_FUNCTION - void operator()(const team_member_t & teamMember) const { - typedef typename std::remove_reference< decltype( lower_xadj_counts(0) ) >::type atomic_incr_type; - - nnz_lno_t ii = teamMember.league_rank() * teamMember.team_size()+ teamMember.team_rank(); - if (ii >= nv) { - return; - } - - size_type xadj_begin = xadj(ii); - size_type xadj_end = xadj(ii + 1); - - Kokkos::parallel_for( - Kokkos::ThreadVectorRange(teamMember, xadj_end - xadj_begin), - [&] (size_type i) { - - size_type adjind = i + xadj_begin; - nnz_lno_t n = adj[adjind]; - if (ii < n && n < nv){ - size_type position = - Kokkos::atomic_fetch_add( &(lower_xadj_counts(ii)), atomic_incr_type(1)); - lower_srcs(position) = ii; - lower_dsts(position) = n; - } - }); - } - }; - - - - template - struct FillLowerTriangle{ - nnz_lno_t nv; - v1 xadj; - v2 adj; - v3 lower_xadj_counts; - v4 lower_srcs; - v4 lower_dsts; - - FillLowerTriangle( - nnz_lno_t nv_, - v1 xadj_, - v2 adj_, - v3 lower_xadj_counts_, - v4 lower_srcs_, - v4 lower_dsts_ - ): nv(nv_), - xadj(xadj_), adj(adj_), - lower_xadj_counts(lower_xadj_counts_), - lower_srcs(lower_srcs_), lower_dsts(lower_dsts_) {} - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t &i) const{ - - size_type xadj_begin = xadj[i]; - size_type xadj_end = xadj[i + 1]; - - for (size_type j = xadj_begin; j < xadj_end; ++j){ - nnz_lno_t n = adj(j); - if (i < n && n < nv){ - size_type position = lower_xadj_counts(i)++; - lower_srcs(position) = i; - lower_dsts(position) = n; - } - } - } - }; - - - - template - void symmetrize_and_calculate_lower_diagonal_edge_list( - nnz_lno_t nv, - row_index_view_type xadj, nonzero_view_type adj){ - - KokkosKernels::Impl::symmetrize_and_get_lower_diagonal_edge_list - - ( - nv, - xadj, - adj, - lower_triangle_src, - lower_triangle_dst); - - size_of_edge_list = lower_triangle_src.extent(0); - - } - - - - template - void get_lower_diagonal_edge_list( - nnz_lno_t nv, size_type ne, - row_index_view_type xadj, nonzero_view_type adj, - size_type &num_out_edges, - nnz_lno_persistent_work_view_t &src, - nnz_lno_persistent_work_view_t &dst){ - - if (size_of_edge_list > 0){ - num_out_edges = size_of_edge_list; - //src = Kokkos::View (this->lower_triangle_src); - //dst = Kokkos::View (this->lower_triangle_dst); - src = (this->lower_triangle_src); - dst = (this->lower_triangle_dst); - } - else { - - size_type_temp_work_view_t lower_count("LowerXADJ", nv + 1); - size_type new_num_edge = 0; - typedef Kokkos::RangePolicy my_exec_space; - - if ( 0 -#if defined( KOKKOS_ENABLE_CUDA ) - || Kokkos::Impl::is_same::value -#endif - ) - { - - - int teamSizeMax = 0; - int vector_size = 0; - - CountLowerTriangleTeam clt (nv, xadj, adj, lower_count); +/** + * This maintains backwards-compatibility with older code that included + * the KokkosGraph_graph_color.hpp file. The new file is renamed to + * KokkosGraph_Distance1Color.hpp to be more consistent with file naming + * used in other places within Kokkos-Kernels. + */ #ifdef KOKKOS_ENABLE_DEPRECATED_CODE - int max_allowed_team_size = team_policy_t::team_size_max(clt); - KokkosKernels::Impl::get_suggested_vector_team_size( - max_allowed_team_size, - vector_size, - teamSizeMax, - nv, ne); -#else - KokkosKernels::Impl::get_suggested_vector_size( - vector_size, - nv, ne); +#include "KokkosGraph_Distance1ColorHandle.hpp" - team_policy_t tmp_policy(nv, Kokkos::AUTO, vector_size); - int max_allowed_team_size = tmp_policy.team_size_max( clt, Kokkos::ParallelForTag() ); +// This interface should be deprecated in version 3.0 +#pragma message("DEPRECATION WARNING: The KokkosGraph_GraphColorHandle.hpp header is replaced by KokkosGraph_Distance1ColorHandle.hpp") - KokkosKernels::Impl::get_suggested_team_size( - max_allowed_team_size, - vector_size, - teamSizeMax); #endif - Kokkos::parallel_for("KokkosGraph::CountLowerTriangleTeam", - team_policy_t(nv / teamSizeMax + 1 , teamSizeMax, vector_size), - clt//, new_num_edge - ); - - KokkosKernels::Impl::inclusive_parallel_prefix_sum - (nv+1, lower_count); - //Kokkos::parallel_scan (my_exec_space(0, nv + 1), PPS(lower_count)); - HandleExecSpace::fence(); - auto lower_total_count = Kokkos::subview(lower_count, nv); - auto hlower = Kokkos::create_mirror_view (lower_total_count); - Kokkos::deep_copy (hlower, lower_total_count); - - new_num_edge = hlower(); - nnz_lno_persistent_work_view_t half_src (Kokkos::ViewAllocateWithoutInitializing("HALF SRC"),new_num_edge); - nnz_lno_persistent_work_view_t half_dst (Kokkos::ViewAllocateWithoutInitializing("HALF DST"),new_num_edge); - Kokkos::parallel_for("KokkosGraph::FillLowerTriangleTeam", - team_policy_t(nv / teamSizeMax + 1 , teamSizeMax, vector_size), - FillLowerTriangleTeam - (nv, xadj, adj, lower_count, half_src, half_dst)); - - src = lower_triangle_src = half_src; - dst = lower_triangle_dst = half_dst; - num_out_edges = size_of_edge_list = new_num_edge; - } - else { - if (nv > 0) { - Kokkos::parallel_reduce("KokkosGraph::CountLowerTriangleTeam",my_exec_space(0,nv), - CountLowerTriangle (nv, xadj, adj, lower_count), new_num_edge); - } - - //Kokkos::parallel_scan (my_exec_space(0, nv + 1), PPS(lower_count)); - - KokkosKernels::Impl::inclusive_parallel_prefix_sum - (nv+1, lower_count); - nnz_lno_persistent_work_view_t half_src (Kokkos::ViewAllocateWithoutInitializing("HALF SRC"),new_num_edge); - nnz_lno_persistent_work_view_t half_dst (Kokkos::ViewAllocateWithoutInitializing("HALF DST"),new_num_edge); - - Kokkos::parallel_for("KokkosGraph::FillLowerTriangleTeam",my_exec_space(0,nv), FillLowerTriangle - (nv, xadj, adj, lower_count, half_src, half_dst)); - - src = lower_triangle_src = half_src; - dst = lower_triangle_dst = half_dst; - num_out_edges = size_of_edge_list = new_num_edge; - } - } - } - - - - struct ReduceMaxFunctor{ - color_view_t colors; - ReduceMaxFunctor(color_view_t cat):colors(cat){} - - KOKKOS_INLINE_FUNCTION - void operator()(const nnz_lno_t &i, color_t & color_max) const { - if (color_max < colors(i) ) color_max = colors(i); - } - - KOKKOS_INLINE_FUNCTION - void join (volatile color_t& dst , const volatile color_t& src) const { // max -plus semiring equivalent of "plus" - if (dst < src) { - dst = src; - } - } - - KOKKOS_INLINE_FUNCTION - void init (color_t& dst) const { - dst = 0; - } - }; - - - nnz_lno_t get_num_colors(){ - if (num_colors == 0){ - typedef typename Kokkos::RangePolicy my_exec_space; - Kokkos::parallel_reduce("KokkosKernels::FindMax", my_exec_space(0, vertex_colors.extent(0)), - ReduceMaxFunctor(vertex_colors) ,num_colors); - } - return num_colors; - } - - - - /** \brief Sets Default Parameter settings for the given algorithm. - */ - void set_defaults (const ColoringAlgorithm &col_algo){ - switch (col_algo){ - case COLORING_VB: - case COLORING_VBBIT: - case COLORING_VBCS: - case COLORING_VBD: - case COLORING_VBDBIT: - case COLORING_SERIAL: - this->conflict_list_type = COLORING_ATOMIC; - this->min_reduction_for_conflictlist = 0.35; - this->min_elements_for_conflictlist = 1000; - this->serial_conflict_resolution = false; - this->tictoc = false; - this->vb_edge_filtering = false; - this->vb_chunk_size = 8; - this->max_number_of_iterations = 200; - this->eb_num_initial_colors = 1; - break; - case COLORING_EB: - this->conflict_list_type = COLORING_PPS; - this->min_reduction_for_conflictlist = 0.35; - this->min_elements_for_conflictlist = 5000; - this->serial_conflict_resolution = false; - this->tictoc = false; - this->vb_edge_filtering = false; - this->vb_chunk_size = 8; - this->max_number_of_iterations = 20000; - this->eb_num_initial_colors = 1; - break; - default: - throw std::runtime_error ("Unknown Coloring Algorithm\n"); - //break; - } - } - - - virtual ~GraphColoringHandle(){}; - - //getters - ColoringAlgorithm get_coloring_algo_type() const {return this->coloring_algorithm_type;} - ConflictList get_conflict_list_type() const {return this->conflict_list_type;} - double get_min_reduction_for_conflictlist() const{return this->min_reduction_for_conflictlist;} - int get_min_elements_for_conflictlist() const{ return this->min_elements_for_conflictlist;} - bool get_serial_conflict_resolution() const{return this->serial_conflict_resolution;} - bool get_tictoc() const{return this->tictoc;} - bool get_vb_edge_filtering() const{return this->vb_edge_filtering;} - int get_vb_chunk_size() const{return this->vb_chunk_size;} - int get_max_number_of_iterations() const{return this->max_number_of_iterations;} - int get_eb_num_initial_colors() const{return this->eb_num_initial_colors;} - - double get_overall_coloring_time() const { return this->overall_coloring_time;} - double get_overall_coloring_time_phase1() const { return this->overall_coloring_time_phase1; } - double get_overall_coloring_time_phase2() const { return this->overall_coloring_time_phase2; } - double get_overall_coloring_time_phase3() const { return this->overall_coloring_time_phase3; } - double get_overall_coloring_time_phase4() const { return this->overall_coloring_time_phase4; } - double get_overall_coloring_time_phase5() const { return this->overall_coloring_time_phase5; } - double get_coloring_time() const { return this->coloring_time;} - int get_num_phases() const { return this->num_phases;} - color_view_t get_vertex_colors() const {return this->vertex_colors;} - bool is_coloring_called() const {return this->is_coloring_called_before;} - //setters - void set_coloring_algo_type(const ColoringAlgorithm &col_algo){this->coloring_algorithm_type = col_algo;} - void set_conflict_list_type(const ConflictList &cl){this->conflict_list_type = cl;} - void set_min_reduction_for_conflictlist(const double &min_reduction){this->min_reduction_for_conflictlist = min_reduction;} - void set_min_elements_for_conflictlist(const int &min_elements){ this->min_elements_for_conflictlist = min_elements;} - void set_serial_conflict_resolution(const bool &use_serial_conflist_resolution){this->serial_conflict_resolution = use_serial_conflist_resolution;} - void set_tictoc(const bool use_tictoc){this->tictoc = use_tictoc;} - void set_vb_edge_filtering(const bool &use_vb_edge_filtering){this->vb_edge_filtering = use_vb_edge_filtering;} - void set_vb_chunk_size(const int &chunksize){this->vb_chunk_size = chunksize;} - void set_max_number_of_iterations(const int &max_phases){this->max_number_of_iterations = max_phases;} - void set_eb_num_initial_colors(const int &num_initial_colors){this->eb_num_initial_colors = num_initial_colors;} - void add_to_overall_coloring_time(const double &coloring_time_){this->overall_coloring_time += coloring_time_;} - void add_to_overall_coloring_time_phase1(const double &coloring_time_){this->overall_coloring_time_phase1 += coloring_time_;} - void add_to_overall_coloring_time_phase2(const double &coloring_time_){this->overall_coloring_time_phase2 += coloring_time_;} - void add_to_overall_coloring_time_phase3(const double &coloring_time_){this->overall_coloring_time_phase3 += coloring_time_;} - void add_to_overall_coloring_time_phase4(const double &coloring_time_){this->overall_coloring_time_phase4 += coloring_time_;} - void add_to_overall_coloring_time_phase5(const double &coloring_time_){this->overall_coloring_time_phase5 += coloring_time_;} - void set_coloring_time(const double &coloring_time_){this->coloring_time = coloring_time_;} - void set_num_phases(const double &num_phases_){this->num_phases = num_phases_;} - void set_vertex_colors( const color_view_t vertex_colors_){ - this->vertex_colors = vertex_colors_; - this->is_coloring_called_before = true; - this->num_colors = 0; - } - -}; - -} // namespace KokkosGraph -#endif // _GRAPHCOLORHANDLE_HPP diff --git a/src/graph/KokkosGraph_graph_color.hpp b/src/graph/KokkosGraph_graph_color.hpp index f35f1939c4..e9220eac8e 100644 --- a/src/graph/KokkosGraph_graph_color.hpp +++ b/src/graph/KokkosGraph_graph_color.hpp @@ -44,12 +44,16 @@ /** * This maintains backwards-compatibility with older code that included - * the KokkosGraph_graph_color.hpp file. The new file is renamed to - * KokkosGraph_GraphColor.hpp to be more consistent with file naming + * the KokkosGraph_graph_color.hpp file. The new file is renamed to + * KokkosGraph_Distance1Color.hpp to be more consistent with file naming * used in other places within Kokkos-Kernels. */ -#include "KokkosGraph_GraphColor.hpp" +#ifdef KOKKOS_ENABLE_DEPRECATED_CODE +#include "KokkosGraph_Distance1Color.hpp" -// TODO: SCAFFOLDING (Add a deprecation warning that this will go away in version 3.0) +// This interface should be deprecated in version 3.0 +#pragma message("DEPRECATION WARNING: The KokkosGraph_graph_color.hpp header will be replaced by KokkosGraph_Distance1Color.hpp") + +#endif diff --git a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp index eaa725c079..0bf0876599 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_MatrixSquared_impl.hpp @@ -49,8 +49,8 @@ #include #include -#include "KokkosGraph_GraphColorHandle.hpp" -#include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_Distance1ColorHandle.hpp" +#include "KokkosGraph_Distance1Color.hpp" #include "KokkosKernels_Handle.hpp" #ifndef _KOKKOSCOLORINGD2MATRIXSQUAREDIMP_HPP diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index b5d14a81a5..25e15b821e 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -40,8 +40,8 @@ // ************************************************************************ //@HEADER */ -#ifndef _KOKKOSCOLORINGD2IMP_HPP -#define _KOKKOSCOLORINGD2IMP_HPP +#ifndef _KOKKOSGRAPH_DISTANCE2COLOR_IMPL_HPP +#define _KOKKOSGRAPH_DISTANCE2COLOR_IMPL_HPP #include #include @@ -58,9 +58,9 @@ #include -#include "KokkosGraph_GraphColor.hpp" -#include "KokkosGraph_GraphColorHandle.hpp" // todo: remove this -#include "KokkosGraph_GraphColorDistance2Handle.hpp" +#include "KokkosGraph_Distance1Color.hpp" +#include "KokkosGraph_Distance1ColorHandle.hpp" // todo: remove this (SCAFFOLDING - WCMCLEN) +#include "KokkosGraph_Distance2ColorHandle.hpp" #include "KokkosKernels_Handle.hpp" @@ -99,7 +99,7 @@ class GraphColorDistance2 using row_lno_host_view_type = typename in_lno_row_view_type::HostMirror; using nnz_lno_host_view_type = typename in_lno_nnz_view_type::HostMirror; using color_host_view_type = typename HandleType::color_host_view_type; - using MyExecSpace = typename HandleType::HandleExecSpace; + using my_exec_space = typename HandleType::HandleExecSpace; using MyTempMemorySpace = typename HandleType::HandleTempMemorySpace; using const_size_type = typename HandleType::const_size_type; using row_lno_view_device_type = typename lno_row_view_t_::device_type; @@ -111,8 +111,8 @@ class GraphColorDistance2 using non_const_clno_nnz_view_t = typename clno_nnz_view_t_::non_const_type; using nnz_lno_temp_work_view_t = typename HandleType::nnz_lno_temp_work_view_type; using single_dim_index_view_type = typename Kokkos::View; - using my_exec_space = Kokkos::RangePolicy; - using team_policy_type = Kokkos::TeamPolicy; + using range_policy_type = Kokkos::RangePolicy; + using team_policy_type = Kokkos::TeamPolicy; using team_member_type = typename team_policy_type::member_type; using non_const_1d_bool_view_t = Kokkos::View; using non_const_1d_size_type_view_type = typename HandleType::non_const_1d_size_type_view_type; @@ -234,7 +234,8 @@ class GraphColorDistance2 */ } - #if 0 // WCMCLEN (EXPERIMENTAL) Distance-2 Degree calculation + #if 0 + // (EXPERIMENTAL) Distance-2 Degree calculation // Compute Distance-2 Degree of the vertices. // -- Keeping this around in case we need to use it later on as an example. size_t degree_d2_max=0; @@ -254,8 +255,7 @@ class GraphColorDistance2 nnz_lno_temp_work_view_t(Kokkos::ViewAllocateWithoutInitializing("vertexList"), this->nv); // init conflictlist sequentially. - Kokkos::parallel_for( - "InitList", my_exec_space(0, this->nv), functorInitList(current_vertexList)); + Kokkos::parallel_for("InitList", range_policy_type(0, this->nv), functorInitList(current_vertexList)); // Next iteratons's conflictList nnz_lno_temp_work_view_t next_iteration_recolorList; @@ -312,7 +312,7 @@ class GraphColorDistance2 this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } - MyExecSpace::fence(); + my_exec_space::fence(); if(this->_ticToc) { @@ -345,7 +345,7 @@ class GraphColorDistance2 next_iteration_recolorList, next_iteration_recolorListLength); - MyExecSpace::fence(); + my_exec_space::fence(); if(_ticToc) { @@ -393,7 +393,7 @@ class GraphColorDistance2 current_vertexListLength); } - MyExecSpace::fence(); + my_exec_space::fence(); if(_ticToc) { @@ -455,7 +455,7 @@ class GraphColorDistance2 Kokkos::deep_copy(d_flags, h_flags); functorVerifyDistance2Coloring vr(this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, d_flags, chunkSize_); - Kokkos::parallel_for("ValidateD2Coloring", my_exec_space(0, num_chunks), vr); + Kokkos::parallel_for("ValidateD2Coloring", range_policy_type(0, num_chunks), vr); // Deep copy flags back to host memory Kokkos::deep_copy(h_flags, d_flags); @@ -482,10 +482,10 @@ class GraphColorDistance2 */ void compute_color_histogram(nnz_lno_temp_work_view_t& histogram) { - KokkosKernels::Impl::kk_get_histogram( + KokkosKernels::Impl::kk_get_histogram( this->nv, this->gc_handle->get_vertex_colors(), histogram); - MyExecSpace::fence(); + my_exec_space::fence(); } @@ -583,7 +583,7 @@ class GraphColorDistance2 functorCalculateD2Degree calculateD2Degree( this->nv, this->xadj, this->adj, this->t_xadj, this->t_adj, v_chunk_size, degree_d2, m_space, hash_size, max_nonzeros); - Kokkos::parallel_for("Compute Degree D2", my_exec_space(0, v_num_chunks), calculateD2Degree); + Kokkos::parallel_for("Compute Degree D2", range_policy_type(0, v_num_chunks), calculateD2Degree); // Compute maximum d2 degree size_t _degree_d2_max = 0; @@ -634,7 +634,7 @@ class GraphColorDistance2 { functorGreedyColorVB gc( this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); + Kokkos::parallel_for("LoopOverChunks", range_policy_type(0, this->nv), gc); } break; @@ -647,7 +647,7 @@ class GraphColorDistance2 { functorGreedyColorVB_BIT gc( this->nv, xadj_, adj_, t_xadj_, t_adj_, vertex_colors_, current_vertexList_, current_vertexListLength_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); + Kokkos::parallel_for("LoopOverChunks", range_policy_type(0, this->nv), gc); } break; @@ -690,7 +690,7 @@ class GraphColorDistance2 vertex_colors_, current_vertexList_, current_vertexListLength_); - Kokkos::parallel_for("LoopOverChunks", my_exec_space(0, this->nv), gc); + Kokkos::parallel_for("LoopOverChunks", range_policy_type(0, this->nv), gc); // prettyPrint1DView(vertex_colors_, "COLORS_GC_VB_BIT",500); } break; @@ -733,7 +733,7 @@ class GraphColorDistance2 current_vertexList_, next_iteration_recolorList_, next_iteration_recolorListLength_); - Kokkos::parallel_reduce("FindConflicts", my_exec_space(0, current_vertexListLength_), conf, output_numUncolored); + Kokkos::parallel_reduce("FindConflicts", range_policy_type(0, current_vertexListLength_), conf, output_numUncolored); } return output_numUncolored; @@ -1517,7 +1517,7 @@ class GraphColorDistance2 const nnz_lno_type _hash_size; const nnz_lno_type _max_nonzeros; - Kokkos::Experimental::UniqueToken tokens; + Kokkos::Experimental::UniqueToken tokens; // EXPERIMENTAL END functorCalculateD2Degree(nnz_lno_type num_verts, @@ -1803,4 +1803,4 @@ void graph_print_distance2_color_histogram(KernelHandle *handle, } // namespace KokkosGraph -#endif // _KOKKOSCOLORINGD2IMP_HPP +#endif // _KOKKOSGRAPH_DISTANCE2COLOR_IMPL_HPP diff --git a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp index c7a64a8b92..c686a92121 100644 --- a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp +++ b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp @@ -47,7 +47,7 @@ #include #include #include -#include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_Distance1Color.hpp" #include "KokkosKernels_Uniform_Initialized_MemoryPool.hpp" #ifndef _KOKKOSGSIMP_HPP #define _KOKKOSGSIMP_HPP diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl.hpp index 8ada468639..ee53fc6ca7 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl.hpp @@ -64,7 +64,7 @@ #include "KokkosKernels_HashmapAccumulator.hpp" #include "KokkosKernels_Uniform_Initialized_MemoryPool.hpp" #include "KokkosSparse_spgemm_handle.hpp" -#include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_Distance1Color.hpp" namespace KokkosSparse{ diff --git a/unit_test/graph/Test_Graph_graph_color.hpp b/unit_test/graph/Test_Graph_graph_color.hpp index d802cc1ce7..00f8e25ec1 100644 --- a/unit_test/graph/Test_Graph_graph_color.hpp +++ b/unit_test/graph/Test_Graph_graph_color.hpp @@ -44,7 +44,7 @@ #include #include -#include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_Distance1Color.hpp" #include "KokkosSparse_CrsMatrix.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_SparseUtils.hpp" diff --git a/unit_test/graph/Test_Graph_graph_color_deterministic.hpp b/unit_test/graph/Test_Graph_graph_color_deterministic.hpp index 8005757985..3e2c6af43e 100644 --- a/unit_test/graph/Test_Graph_graph_color_deterministic.hpp +++ b/unit_test/graph/Test_Graph_graph_color_deterministic.hpp @@ -44,7 +44,7 @@ #include #include -#include "KokkosGraph_GraphColor.hpp" +#include "KokkosGraph_Distance1Color.hpp" #include "KokkosSparse_CrsMatrix.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_SparseUtils.hpp" diff --git a/unit_test/graph/Test_Graph_graph_color_distance2.hpp b/unit_test/graph/Test_Graph_graph_color_distance2.hpp index a638fc406f..986a617655 100644 --- a/unit_test/graph/Test_Graph_graph_color_distance2.hpp +++ b/unit_test/graph/Test_Graph_graph_color_distance2.hpp @@ -104,10 +104,10 @@ run_graphcolor_d2(crsMat_type bool d2_coloring_is_valid = false; bool d2_coloring_validation_flags[4] = { false }; - d2_coloring_is_valid = graph_verify_distance2_color(&kh, num_rows_1, num_cols_1, - input_mat.graph.row_map,input_mat.graph.entries, - input_mat.graph.row_map, input_mat.graph.entries, - d2_coloring_validation_flags); + d2_coloring_is_valid = KokkosGraph::Impl::graph_verify_distance2_color(&kh, num_rows_1, num_cols_1, + input_mat.graph.row_map,input_mat.graph.entries, + input_mat.graph.row_map, input_mat.graph.entries, + d2_coloring_validation_flags); From 6b98b750e20f5126ca7dc23a4db5aa45133683c5 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Feb 2019 12:03:33 -0700 Subject: [PATCH 127/190] D2GC: Addressing PR requests --- src/graph/KokkosGraph_Distance1ColorHandle.hpp | 6 +++--- src/graph/impl/KokkosGraph_Distance2Color_impl.hpp | 9 ++------- 2 files changed, 5 insertions(+), 10 deletions(-) diff --git a/src/graph/KokkosGraph_Distance1ColorHandle.hpp b/src/graph/KokkosGraph_Distance1ColorHandle.hpp index 9ad029a762..614c152d56 100644 --- a/src/graph/KokkosGraph_Distance1ColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance1ColorHandle.hpp @@ -61,8 +61,8 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_VBD, // Vertex Based Deterministic Coloring COLORING_VBDBIT, // Vertex Based Deterministic Coloring with bit array COLORING_EB, // Edge Based Coloring - COLORING_SERIAL2, - COLORING_SPGEMM, + COLORING_SERIAL2, // Serial Distance-2 Graph Coloring (kept here for backwards compatibility for SPGEMM and other use cases) + //COLORING_SPGEMM, // SCAFFOLDING - WCMCLEN (this should be removed) }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; @@ -498,7 +498,7 @@ class GraphColoringHandle size_type new_num_edge = 0; typedef Kokkos::RangePolicy my_exec_space; - if ( 0 + if ( false #if defined( KOKKOS_ENABLE_CUDA ) || Kokkos::Impl::is_same::value #endif diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 25e15b821e..00cecaef12 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -960,7 +960,6 @@ class GraphColorDistance2 // * The Distance-1 code used the knowledge of the degree of the vertex to cap the number of iterations // but in distance-2 we'd need the total vertices at distance-2 which we don't easily have aprioi. // This could be as big as all the vertices in the graph if diameter(G)=2... - // * TODO: Determine if we can cap this at something lower than nv. for(color_type offset = 0; !foundColor && offset < nv; offset += VB_D2_COLORING_FORBIDDEN_SIZE) { // initialize @@ -1547,8 +1546,7 @@ class GraphColorDistance2 KOKKOS_INLINE_FUNCTION void operator()(const nnz_lno_type chunk_id) const { - #if 1 - // EXPERIMENTAL + // BEGIN EXPERIMENTAL // Get a unique token since we aren't using TeamPolicy (for UniformMemoryPool, that the HashmapAccumulator requires) auto tid = tokens.acquire(); @@ -1577,7 +1575,7 @@ class GraphColorDistance2 hash_map.max_value_size = _max_nonzeros; // Max # of nonzeros that can be added into the hash table nnz_lno_type pow2_hash_func = _hash_size - 1; - #endif + // END EXPERIMENTAL for(nnz_lno_type ichunk = 0; ichunk < _chunk_size; ichunk++) { @@ -1624,8 +1622,6 @@ class GraphColorDistance2 } // for vid_d1_adj ... // EXPERIMENTAL BEGIN - #if 1 - // std::cout << "::: " << vid << " -> " << used_hash_size << std::endl; _degree_d2(vid) = used_hash_size; @@ -1635,7 +1631,6 @@ class GraphColorDistance2 nnz_lno_type dirty_hash = globally_used_hash_indices[ i ]; hash_map.hash_begins[ dirty_hash ] = -1; } - #endif // EXPERIMENTAL END } // for ichunk ... From 9ed39e2fae21d3cb953ae2d5a074e0d36ab1a11b Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 14 Feb 2019 13:27:56 -0700 Subject: [PATCH 128/190] D2GC: Addressing PR requests --- src/graph/KokkosGraph_Distance1Color.hpp | 37 +++++++++++---- .../KokkosGraph_Distance1ColorHandle.hpp | 1 - src/graph/KokkosGraph_Distance2Color.hpp | 1 - .../impl/KokkosSparse_gauss_seidel_impl.hpp | 16 +++---- .../impl/KokkosSparse_spgemm_impl_color.hpp | 46 +++++++++---------- 5 files changed, 58 insertions(+), 43 deletions(-) diff --git a/src/graph/KokkosGraph_Distance1Color.hpp b/src/graph/KokkosGraph_Distance1Color.hpp index a3b2f7c839..2fdccae30b 100644 --- a/src/graph/KokkosGraph_Distance1Color.hpp +++ b/src/graph/KokkosGraph_Distance1Color.hpp @@ -137,17 +137,19 @@ void graph_color( } -// Distance 2 graph coloring -- serial only -- should be replaced by the Distance2GraphColoring +// Distance 2 graph coloring -- serial only -- +// todo: move this over to the Distance2 handle template -void d2_graph_color( +void graph_compute_distance2_color_serial( KernelHandle *handle, typename KernelHandle::nnz_lno_t num_rows, typename KernelHandle::nnz_lno_t num_cols, lno_row_view_t_ row_map, lno_nnz_view_t_ row_entries, - lno_col_view_t_ col_map, //if graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + //if graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, lno_colnnz_view_t_ col_entries) { @@ -158,12 +160,13 @@ void d2_graph_color( typedef typename KernelHandle::GraphColoringHandleType::color_view_t color_view_type; - typedef typename Impl::GraphColorBaseGraphColoring; + // typedef typename Impl::GraphColorBaseGraphColoring; int num_phases = 0; switch (algorithm) { + #if 0 // SERIAL shouldn't be in the d2 coloring function since you can get it from graph_color() case COLORING_SERIAL: { color_view_type colors_out = color_view_type("Graph Colors", num_rows); @@ -173,9 +176,10 @@ void d2_graph_color( gch->set_vertex_colors(colors_out); break; } + #endif - // TODO: SCAFFOLDING: Remove SERIAL Distance-2 Graph Coloring from this interface - // + // todo: Remove SERIAL Distance-2 Graph Coloring from this interface + // case COLORING_SERIAL2: { color_view_type colors_out = color_view_type("Graph Colors", num_rows); @@ -190,8 +194,9 @@ void d2_graph_color( default: { color_view_type colors_out = color_view_type("Graph Colors", num_rows); - BaseGraphColoring gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); - gc.d2_color_graph/**/(colors_out, num_phases, num_cols, col_map, col_entries); + Impl::GraphColor2 + gc(num_rows, row_entries.extent(0), row_map, row_entries, gch); + gc.d2_color_graph(colors_out, num_phases, num_cols, col_map, col_entries); gch->set_num_phases(num_phases); gch->set_vertex_colors(colors_out); break; @@ -204,6 +209,22 @@ void d2_graph_color( } +#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) +template +void d2_graph_color(KernelHandle *handle, + typename KernelHandle::nnz_lno_t num_rows, + typename KernelHandle::nnz_lno_t num_cols, + lno_row_view_t_ row_map, + lno_nnz_view_t_ row_entries, + //if graph is symmetric, simply give same for col_map and row_map, and row_entries and col_entries. + lno_col_view_t_ col_map, + lno_colnnz_view_t_ col_entries) +{ + graph_compute_distance2_color_serial(handle, num_rows, num_cols, row_map, row_entries, col_map, col_entries); + std::cout << "Deprecation warning: d2_graph_color() will be replaced with graph_compute_distance2_color_serial()" << std::endl; +} +#endif + } // end namespace Experimental } // end namespace KokkosGraph diff --git a/src/graph/KokkosGraph_Distance1ColorHandle.hpp b/src/graph/KokkosGraph_Distance1ColorHandle.hpp index 614c152d56..4d479be3d9 100644 --- a/src/graph/KokkosGraph_Distance1ColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance1ColorHandle.hpp @@ -62,7 +62,6 @@ enum ColoringAlgorithm { COLORING_DEFAULT, COLORING_VBDBIT, // Vertex Based Deterministic Coloring with bit array COLORING_EB, // Edge Based Coloring COLORING_SERIAL2, // Serial Distance-2 Graph Coloring (kept here for backwards compatibility for SPGEMM and other use cases) - //COLORING_SPGEMM, // SCAFFOLDING - WCMCLEN (this should be removed) }; enum ConflictList{COLORING_NOCONFLICT, COLORING_ATOMIC, COLORING_PPS}; diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index 93c79bf5e8..fdb952e83d 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -155,7 +155,6 @@ void graph_compute_distance2_color(KernelHandle *handle, } - } // end namespace Experimental } // end namespace KokkosGraph diff --git a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp index c686a92121..4b2c24ac8a 100644 --- a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp +++ b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp @@ -588,20 +588,20 @@ namespace KokkosSparse{ - void initialize_symbolic(){ + void initialize_symbolic() + { typename HandleType::GraphColoringHandleType *gchandle = this->handle->get_graph_coloring_handle(); - if (gchandle == NULL){ - - this->handle->create_graph_coloring_handle(); - //this->handle->create_gs_handle(); - this->handle->get_gs_handle()->set_owner_of_coloring(); - gchandle = this->handle->get_graph_coloring_handle(); + if (gchandle == NULL) + { + this->handle->create_graph_coloring_handle(); + //this->handle->create_gs_handle(); + this->handle->get_gs_handle()->set_owner_of_coloring(); + gchandle = this->handle->get_graph_coloring_handle(); } - const_lno_row_view_t xadj = this->row_map; const_lno_nnz_view_t adj = this->entries; size_type nnz = adj.extent(0); diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index a7f8a4fb3a..c0f0ac3c7d 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -501,32 +501,29 @@ void { - timer1.reset(); - - this->handle->create_graph_coloring_handle(); + this->handle->create_graph_coloring_handle(); typename HandleType::GraphColoringHandleType::color_view_t vertex_color_view; - if (this->handle->get_spgemm_handle()->coloring_input_file == ""){ - //for now only sequential one exists. - //find distance-2 graph coloring - handle->get_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_SERIAL2); - KokkosGraph::Experimental::d2_graph_color - (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); + if (this->handle->get_spgemm_handle()->coloring_input_file == "") + { + //for now only sequential one exists. + //find distance-2 graph coloring - // WCMCLEN: EXPERIMENTAL - We should switch this to use the distance-2 graph coloring handle at - // some point, but it might not be 'simple' since this is being used in - // the SPGEMM code. - // handle->get_distance2_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_D2_SERIAL); - // KokkosGraph::Experimental::graph_compute_distance2_color - // (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); + handle->get_graph_coloring_handle()->set_algorithm(KokkosGraph::COLORING_SERIAL2); - original_num_colors = handle->get_graph_coloring_handle()->get_num_colors(); + KokkosGraph::Experimental::graph_compute_distance2_color_serial + + (this->handle, a_row_cnt, b_col_cnt, rowmapC, entryIndicesC_, transpose_col_xadj, transpose_col_adj); - if (KOKKOSKERNELS_VERBOSE){ - std::cout << "\t\tNum colors:" << handle->get_graph_coloring_handle()->get_num_colors() << " coloring time:" << timer1.seconds() << std::endl; + original_num_colors = handle->get_graph_coloring_handle()->get_num_colors(); + + if (KOKKOSKERNELS_VERBOSE) + { + std::cout << "\t\tNum colors:" << handle->get_graph_coloring_handle()->get_num_colors() + << " coloring time:" << timer1.seconds() << std::endl; } vertex_color_view = handle->get_graph_coloring_handle()->get_vertex_colors(); @@ -534,19 +531,18 @@ void KokkosKernels::Impl::kk_write_1Dview_to_file(vertex_color_view, this->handle->get_spgemm_handle()->coloring_output_file.c_str()); } } - else { + else + { vertex_color_view = typename HandleType::GraphColoringHandleType::color_view_t("vertex colors from file", a_row_cnt); - KokkosKernels::Impl::kk_read_1Dview_from_file(vertex_color_view, this->handle->get_spgemm_handle()->coloring_input_file.c_str()); - KokkosKernels::Impl::view_reduce_max + KokkosKernels::Impl::kk_read_1Dview_from_file(vertex_color_view, this->handle->get_spgemm_handle()->coloring_input_file.c_str()); + KokkosKernels::Impl::view_reduce_max (a_row_cnt, vertex_color_view, original_num_colors); MyExecSpace::fence(); //KokkosKernels::Impl::kk_print_1Dview(vertex_color_view); - } - num_multi_color_steps = original_num_colors; - num_colors_in_one_step = 1; - + num_multi_color_steps = original_num_colors; + num_colors_in_one_step = 1; vertex_colors_to_store = nnz_lno_persistent_work_view_t(Kokkos::ViewAllocateWithoutInitializing("persistent_color_view"), a_row_cnt); From 878e7521e95fa9fb7c6af6c5cd7de9b8de68d8e6 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Fri, 15 Feb 2019 12:30:56 -0700 Subject: [PATCH 129/190] Remove unused variable Exposed by Jenkins build KokkosKernels_White_XL_16_1_OpenMP_Serial Changes to be committed: modified: KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp --- .../KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index 8ceea5f3ac..a96661febf 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -92,7 +92,7 @@ namespace KokkosBatched { for (int m_htl=1;m_htl<(m-1);++m_htl) { // part 2x2 into 3x3 H_part3x3.partWithABR(H_part2x2, 1, 1); - const int n_hbr = m - m_htl; + //const int n_hbr = m - m_htl; /// ----------------------------------------------------- value_type *chi1 = H_part3x3.A11-hs1; value_type *chi2 = H_part3x3.A21-hs1; From 56826ab0b9312a56ab6b3cf358ba754b36b065d6 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 20 Feb 2019 17:12:30 -0700 Subject: [PATCH 130/190] KokkosBatched - example unified code for performance --- .../KokkosBatched_Test_BlockTridiag.cpp | 592 ++++++++++++++++++ src/batched/KokkosBatched_Copy_Decl.hpp | 26 + 2 files changed, 618 insertions(+) create mode 100644 perf_test/batched/KokkosBatched_Test_BlockTridiag.cpp diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiag.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiag.cpp new file mode 100644 index 0000000000..26562bf4f7 --- /dev/null +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiag.cpp @@ -0,0 +1,592 @@ +/// Kokkos headers +#include "Kokkos_Core.hpp" +#include "impl/Kokkos_Timer.hpp" +#include "Kokkos_Random.hpp" + +/// KokkosKernels headers +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define KOKKOSBATCHED_PROFILE 1 +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) +#include "cuda_profiler_api.h" +#endif + +typedef Kokkos::DefaultExecutionSpace exec_space; +typedef typename exec_space::memory_space memory_space; +typedef Kokkos::DefaultHostExecutionSpace host_space; + +typedef double value_type; + +/// 128*128*128/16*5 * (2*8) / 16 +/// +/// simd typedefs +/// +using namespace KokkosBatched::Experimental; + +static constexpr int vector_length = DefaultVectorLength::value; +static constexpr int internal_vector_length = DefaultInternalVectorLength::value; + +typedef Vector,vector_length> vector_type; +typedef Vector,internal_vector_length> internal_vector_type; + +template +struct FactorizeModeAndAlgo; + +template<> +struct FactorizeModeAndAlgo { + typedef Mode::Serial mode_type; + typedef Algo::Level3::Blocked algo_type; +}; + +#if defined(KOKKOS_ENABLE_CUDA) +template<> +struct FactorizeModeAndAlgo { + typedef Mode::Team mode_type; + typedef Algo::Level3::Unblocked algo_type; +}; +#endif + +template +struct SolveModeAndAlgo; + +template<> +struct SolveModeAndAlgo { + typedef Mode::Serial mode_type; + typedef Algo::Level2::Blocked algo_type; +}; + +#if defined(KOKKOS_ENABLE_CUDA) +template<> +struct SolveModeAndAlgo { + typedef Mode::Team mode_type; + typedef Algo::Level2::Unblocked algo_type; +}; +#endif + +int main(int argc, char* argv[]) { + Kokkos::initialize(argc, argv); + { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + Kokkos::print_configuration(std::cout); + + typedef Kokkos::Details::ArithTraits ats; + Kokkos::Impl::Timer timer; + + /// + /// input arguments parsing + /// + int N = 128*128; /// # of problems (batch size) + int L = 128; /// length of block tridiags + int Blk = 5; /// block dimension + int Nvec = 1; + int S = 0; /// scratch size + int niter = 1; + for (int i=1;i Av("A", + N/vector_length, L, 3, Blk, Blk); + + /// double + Kokkos::View As((value_type*)Av.data(), + Av.extent(0), + Av.extent(1), + Av.extent(2), + Av.extent(3), + Av.extent(4), + vector_length); + + /// double 2 + Kokkos::View Ai((internal_vector_type*)Av.data(), + Av.extent(0), + Av.extent(1), + Av.extent(2), + Av.extent(3), + Av.extent(4), + vector_length/internal_vector_length); + /// double 16 + Kokkos::View xv("x", + N/vector_length, Nvec, L, Blk); + + /// double + Kokkos::View xs((value_type*)xv.data(), + xv.extent(0), + xv.extent(1), + xv.extent(2), + xv.extent(3), + vector_length); + + /// double 2 + Kokkos::View xi((internal_vector_type*)xv.data(), + xv.extent(0), + xv.extent(1), + xv.extent(2), + xv.extent(3), + vector_length/internal_vector_length); + + /// double 16 + Kokkos::View bv("b", + N/vector_length, Nvec, L, Blk); + + /// double + Kokkos::View bs((value_type*)bv.data(), + bv.extent(0), + bv.extent(1), + bv.extent(2), + bv.extent(3), + vector_length); + + /// double 2 + Kokkos::View bi((internal_vector_type*)bv.data(), + bv.extent(0), + bv.extent(1), + bv.extent(2), + bv.extent(3), + vector_length/internal_vector_length); + + + /// double copy of A + Kokkos::View Acopy("Acopy", + As.extent(0), + As.extent(1), + As.extent(2), + As.extent(3), + As.extent(4), + As.extent(5)); + + Kokkos::View rs("rs", + bs.extent(0), + bs.extent(1), + bs.extent(2), + bs.extent(3), + bs.extent(4)); + + auto AA = Ai; + auto bb = bi; + auto xx = xi; + + // auto AA = As; + // auto bb = bs; + // auto xx = xs; + + /// + /// set identity + /// + if (0) { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStart(); +#endif + timer.reset(); + using policy_type = Kokkos::TeamPolicy; + policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + Kokkos::parallel_for + ("setTridiagToIdentity", + policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,AA.extent(1)),[&](const int &j) { + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + for (int k=0;k random(13245); + Kokkos::fill_random(As, random, value_type(1.0)); + Kokkos::fill_random(bs, random, value_type(1.0)); + + Kokkos::deep_copy(Acopy, As); + + /// + /// factorize the matrix + /// + if (1) { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStart(); +#endif + timer.reset(); + using policy_type = Kokkos::TeamPolicy; + policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + Kokkos::parallel_for + ("factorize", + policy.set_scratch_size(0,Kokkos::PerTeam(S)), + KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + typedef FactorizeModeAndAlgo default_mode_and_algo_type; + typedef default_mode_and_algo_type::mode_type mode_type; + typedef default_mode_and_algo_type::algo_type algo_type; + + const int i = member.league_rank(); + + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + auto AAA = Kokkos::subview(AA, i, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL(), v); + + /// subview patterns + auto A = Kokkos::subview(AAA, 0, 1, Kokkos::ALL(), Kokkos::ALL()); + auto B = Kokkos::subview(AAA, 0, 2, Kokkos::ALL(), Kokkos::ALL()); + auto C = Kokkos::subview(AAA, 0, 0, Kokkos::ALL(), Kokkos::ALL()); + auto D = Kokkos::subview(AAA, 0, 1, Kokkos::ALL(), Kokkos::ALL()); + + if (L == 1) { + A.assign_data( &AAA(0, 1, 0, 0) ); + LU::invoke(member, A); + } else { + for (int k=0;k<(L-1);++k) { + A.assign_data( &AAA(k, 1, 0, 0) ); + B.assign_data( &AAA(k, 2, 0, 0) ); + C.assign_data( &AAA(k, 0, 0, 0) ); + D.assign_data( &AAA(k+1, 1, 0, 0) ); + + LU + ::invoke(member, A); + Trsm + ::invoke(member, 1.0, A, B); + Trsm + ::invoke(member, 1.0, A, C); + Gemm + ::invoke(member, -1.0, C, B, 1.0, D); + } + LU + ::invoke(member, D); + } + }); + }); + Kokkos::fence(); + const double t = timer.seconds(); +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + printf("factorize time = %f , # of factorization per min = %f \n", t, 1.0/t*60); + } + + /// + /// solve the matrix 20 times + /// + if (1) { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStart(); +#endif + timer.reset(); + typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + using policy_type = Kokkos::TeamPolicy; + policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + for (int iter=0;iter default_mode_and_algo_type; + typedef default_mode_and_algo_type::mode_type mode_type; + typedef default_mode_and_algo_type::algo_type algo_type; + + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(AA, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto B = Kokkos::subview(AA, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); + auto C = Kokkos::subview(AA, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); + + for (int jvec=0;jvec + ::invoke(member, bk, xb); + member.team_barrier(); + } + } + const int kend = L - 1; + for (int k=0;k + ::invoke(member, bk, xb); + } + + Trsv + ::invoke(member, 1.0, LT, xt); + + Gemv + ::invoke(member, -1.0, LB, xt, 1.0, xb); + } + { + LT.assign_data(&A(kend, 0, 0)); + xt.assign_data(&x(kend, 0)); + Trsv + ::invoke(member, 1.0, LT, xt); + } + } /// end forward substitution + + /// + /// backward substitution + /// + { + auto UT = Kokkos::subview(B, 0, Kokkos::ALL(), Kokkos::ALL()); + auto UB = Kokkos::subview(A, 0, Kokkos::ALL(), Kokkos::ALL()); + + const int kbegin = L - 1; + for (int k=kbegin;k>0;--k) { + UT.assign_data(&B(k-1, 0, 0)); + UB.assign_data(&A(k, 0, 0)); + + xt.assign_data(&x(k-1, 0, 0)); + xb.assign_data(&x(k, 0, 0)); + + Trsv + ::invoke(member, 1.0, UB, xb); + + Gemv + ::invoke(member, -1.0, UT, xb, 1.0, xt); + } + { + UB.assign_data(&A(0, 0, 0)); + xb.assign_data(&x(0, 0)); + Trsv + ::invoke(member, 1.0, UB, xb); + } + } // end backward substitution + } + }); + }); + Kokkos::fence(); + } + const double t = timer.seconds(); +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + printf("solve time = %f , # of solves per min = %f\n", t, 1.0/t*60*niter); + } + + /// + /// compute residual + /// + { + typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + using policy_type = Kokkos::TeamPolicy; + policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); + Kokkos::parallel_for + ("compute residual", + policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, Acopy.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(Acopy, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto B = Kokkos::subview(Acopy, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); + auto C = Kokkos::subview(Acopy, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); + + for (int jvec=0;jvec + ::invoke(member, b0, r0); + TeamGemv + ::invoke(member, -1.0, A0, x0, 1.0, r0); + } else { + int k = 0; + { + /// first row + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + auto B2 = Kokkos::subview(B, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + auto x2 = Kokkos::subview(x, k+1, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, B2, x2, 1.0, rk); + ++k; + } + for (;k<(L-1);++k) { + auto C0 = Kokkos::subview(C, k-1, Kokkos::ALL(), Kokkos::ALL()); + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + auto B2 = Kokkos::subview(B, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x0 = Kokkos::subview(x, k-1, Kokkos::ALL()); + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + auto x2 = Kokkos::subview(x, k+1, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, C0, x0, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, B2, x2, 1.0, rk); + } + { + // last row + auto C0 = Kokkos::subview(C, k-1, Kokkos::ALL(), Kokkos::ALL()); + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x0 = Kokkos::subview(x, k-1, Kokkos::ALL()); + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, C0, x0, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + } + } + } + }); + }); + Kokkos::fence(); + auto rs_host = Kokkos::create_mirror_view(rs); + auto bs_host = Kokkos::create_mirror_view(bs); + Kokkos::deep_copy(rs_host, rs); + Kokkos::deep_copy(bs_host, bs); + Kokkos::fence(); + { + double norm2 = 0, diff2 = 0; + for (int i0=0;i0 + struct Copy { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialCopy::invoke(A, B); + } else if (std::is_same::value) { + r_val = TeamCopy::invoke(member, A, B); + } + return r_val; + } + }; + + } } From 50fc2a8e7f3d83da6ebe744e44b99807b125576d Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 21 Feb 2019 10:13:36 -0700 Subject: [PATCH 131/190] KokkosBatched - testing iterative method --- ...osBatched_Test_BlockTridiagAsyncJacobi.cpp | 580 ++++++++++++++++++ ...KokkosBatched_Test_BlockTridiagDirect.cpp} | 66 +- .../KokkosBatched_SetIdentity_Decl.hpp | 22 + 3 files changed, 637 insertions(+), 31 deletions(-) create mode 100644 perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp rename perf_test/batched/{KokkosBatched_Test_BlockTridiag.cpp => KokkosBatched_Test_BlockTridiagDirect.cpp} (92%) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp new file mode 100644 index 0000000000..98a2c9ec73 --- /dev/null +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp @@ -0,0 +1,580 @@ +/// Kokkos headers +#include "Kokkos_Core.hpp" +#include "impl/Kokkos_Timer.hpp" +#include "Kokkos_Random.hpp" + +/// KokkosKernels headers +#include "KokkosBatched_Util.hpp" +#include "KokkosBatched_Vector.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define KOKKOSBATCHED_PROFILE 1 +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) +#include "cuda_profiler_api.h" +#endif + +typedef Kokkos::DefaultExecutionSpace exec_space; +typedef typename exec_space::memory_space memory_space; +typedef Kokkos::DefaultHostExecutionSpace host_space; + +typedef double value_type; + +/// 128*128*128/16*5 * (2*8) / 16 +/// +/// simd typedefs +/// +using namespace KokkosBatched::Experimental; + +static constexpr int vector_length = DefaultVectorLength::value; +static constexpr int internal_vector_length = DefaultInternalVectorLength::value; + +typedef Vector,vector_length> vector_type; +typedef Vector,internal_vector_length> internal_vector_type; + +template +struct InverseDiagonalsModeAndAlgo; + +template<> +struct InverseDiagonalsModeAndAlgo { + typedef Mode::Serial mode_type; + typedef Algo::Level3::Blocked algo_type; +}; + +#if defined(KOKKOS_ENABLE_CUDA) +template<> +struct InverseDiagonalsModeAndAlgo { + typedef Mode::Team mode_type; + typedef Algo::Level3::Unblocked algo_type; +}; +#endif + +template +struct SolveModeAndAlgo; + +template<> +struct SolveModeAndAlgo { + typedef Mode::Serial mode_type; + typedef Algo::Level2::Blocked algo_type; +}; + +#if defined(KOKKOS_ENABLE_CUDA) +template<> +struct SolveModeAndAlgo { + typedef Mode::Team mode_type; + typedef Algo::Level2::Unblocked algo_type; +}; +#endif + +int main(int argc, char* argv[]) { + Kokkos::initialize(argc, argv); + { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + Kokkos::print_configuration(std::cout); + + typedef Kokkos::Details::ArithTraits ats; + Kokkos::Impl::Timer timer; + + /// + /// input arguments parsing + /// + int N = 128*128; /// # of problems (batch size) + int L = 128; /// length of block tridiags + int Blk = 5; /// block dimension + int Nvec = 1; + int S = 0; /// scratch size + int niter = 1; + for (int i=1;i Av("A", + N/vector_length, L, 4, Blk, Blk); + + /// double + Kokkos::View As((value_type*)Av.data(), + Av.extent(0), + Av.extent(1), + Av.extent(2), + Av.extent(3), + Av.extent(4), + vector_length); + + /// double 2 + Kokkos::View Ai((internal_vector_type*)Av.data(), + Av.extent(0), + Av.extent(1), + Av.extent(2), + Av.extent(3), + Av.extent(4), + vector_length/internal_vector_length); + /// double 16 + Kokkos::View xv("x", + N/vector_length, Nvec, L, Blk); + + /// double + Kokkos::View xs((value_type*)xv.data(), + xv.extent(0), + xv.extent(1), + xv.extent(2), + xv.extent(3), + vector_length); + + /// double 2 + Kokkos::View xi((internal_vector_type*)xv.data(), + xv.extent(0), + xv.extent(1), + xv.extent(2), + xv.extent(3), + vector_length/internal_vector_length); + + /// double 16 + Kokkos::View bv("b", + N/vector_length, Nvec, L, Blk); + + /// double + Kokkos::View bs((value_type*)bv.data(), + bv.extent(0), + bv.extent(1), + bv.extent(2), + bv.extent(3), + vector_length); + + /// double 2 + Kokkos::View bi((internal_vector_type*)bv.data(), + bv.extent(0), + bv.extent(1), + bv.extent(2), + bv.extent(3), + vector_length/internal_vector_length); + + + /// double copy of A + Kokkos::View Acopy("Acopy", + As.extent(0), + As.extent(1), + As.extent(2), + As.extent(3), + As.extent(4), + As.extent(5)); + + Kokkos::View rs("rs", + bs.extent(0), + bs.extent(1), + bs.extent(2), + bs.extent(3), + bs.extent(4)); + + auto AA = Ai; + auto bb = bi; + auto xx = xi; + + // auto AA = As; + // auto bb = bs; + // auto xx = xs; + + + /// randomize input + Kokkos::Random_XorShift64_Pool random(13245); + Kokkos::fill_random(As, random, value_type(1.0)); + Kokkos::fill_random(bs, random, value_type(1.0)); + + /// + /// diagonal dominant + /// + if (1) { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStart(); +#endif + using policy_type = Kokkos::TeamPolicy; + using member_type = typename policy_type::member_type; + policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + Kokkos::parallel_for + ("diagonal dominant", + policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,AA.extent(1)),[&](const int &j) { + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + for (int k=0;k scratch_view_type; + + using policy_type = Kokkos::TeamPolicy; + const int per_team_scratch = scratch_view_type::shmem_size(Blk, Blk, AA.extent(5)); + policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); + Kokkos::parallel_for + ("inverse diagonals", + policy.set_scratch_size(0,Kokkos::PerTeam(S)), + KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + typedef InverseDiagonalsModeAndAlgo default_mode_and_algo_type; + typedef default_mode_and_algo_type::mode_type mode_type; + typedef default_mode_and_algo_type::algo_type algo_type; + + const int i = member.league_rank()/L; + const int k = member.league_rank()%L; + + scratch_view_type WW(member.team_scratch(0), Blk, Blk, AA.extent(5)); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(AA, i, k, 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto D = Kokkos::subview(AA, i, k, 3, Kokkos::ALL(), Kokkos::ALL(), v); + auto W = Kokkos::subview(WW, Kokkos::ALL(), Kokkos::ALL(), v); + + Copy + ::invoke(member, A, W); + SetIdentity + ::invoke(member, D); + member.barrier(); + LU::invoke(member, W); + Trsm + ::invoke(member, 1.0, W, D); + Trsm + ::invoke(member, 1.0, W, D); + }); + }); + Kokkos::fence(); + const double t = timer.seconds(); +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + printf("inverse time = %f , # of inverse per min = %f \n", t, 1.0/t*60); + } + + /// + /// solve the matrix 20 times + /// + if (0) { +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStart(); +#endif + timer.reset(); + typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + using policy_type = Kokkos::TeamPolicy; + policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + for (int iter=0;iter default_mode_and_algo_type; + typedef default_mode_and_algo_type::mode_type mode_type; + typedef default_mode_and_algo_type::algo_type algo_type; + + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(AA, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto B = Kokkos::subview(AA, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); + auto C = Kokkos::subview(AA, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); + + for (int jvec=0;jvec + ::invoke(member, bk, xb); + member.team_barrier(); + } + } + const int kend = L - 1; + for (int k=0;k + ::invoke(member, bk, xb); + } + + Trsv + ::invoke(member, 1.0, LT, xt); + + Gemv + ::invoke(member, -1.0, LB, xt, 1.0, xb); + } + { + LT.assign_data(&A(kend, 0, 0)); + xt.assign_data(&x(kend, 0)); + Trsv + ::invoke(member, 1.0, LT, xt); + } + } /// end forward substitution + + /// + /// backward substitution + /// + { + auto UT = Kokkos::subview(B, 0, Kokkos::ALL(), Kokkos::ALL()); + auto UB = Kokkos::subview(A, 0, Kokkos::ALL(), Kokkos::ALL()); + + const int kbegin = L - 1; + for (int k=kbegin;k>0;--k) { + UT.assign_data(&B(k-1, 0, 0)); + UB.assign_data(&A(k, 0, 0)); + + xt.assign_data(&x(k-1, 0, 0)); + xb.assign_data(&x(k, 0, 0)); + + Trsv + ::invoke(member, 1.0, UB, xb); + + Gemv + ::invoke(member, -1.0, UT, xb, 1.0, xt); + } + { + UB.assign_data(&A(0, 0, 0)); + xb.assign_data(&x(0, 0)); + Trsv + ::invoke(member, 1.0, UB, xb); + } + } // end backward substitution + } + }); + }); + Kokkos::fence(); + } + const double t = timer.seconds(); +#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) + cudaProfilerStop(); +#endif + printf("solve time = %f , # of solves per min = %f\n", t, 1.0/t*60*niter); + } + + /// + /// compute residual + /// + if (0) { + typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + using policy_type = Kokkos::TeamPolicy; + policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); + Kokkos::parallel_for + ("compute residual", + policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + const int i = member.league_rank(); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, Acopy.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(Acopy, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto B = Kokkos::subview(Acopy, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); + auto C = Kokkos::subview(Acopy, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); + + for (int jvec=0;jvec + ::invoke(member, b0, r0); + TeamGemv + ::invoke(member, -1.0, A0, x0, 1.0, r0); + } else { + int k = 0; + { + /// first row + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + auto B2 = Kokkos::subview(B, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + auto x2 = Kokkos::subview(x, k+1, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, B2, x2, 1.0, rk); + ++k; + } + for (;k<(L-1);++k) { + auto C0 = Kokkos::subview(C, k-1, Kokkos::ALL(), Kokkos::ALL()); + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + auto B2 = Kokkos::subview(B, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x0 = Kokkos::subview(x, k-1, Kokkos::ALL()); + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + auto x2 = Kokkos::subview(x, k+1, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, C0, x0, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, B2, x2, 1.0, rk); + } + { + // last row + auto C0 = Kokkos::subview(C, k-1, Kokkos::ALL(), Kokkos::ALL()); + auto A1 = Kokkos::subview(A, k, Kokkos::ALL(), Kokkos::ALL()); + + auto x0 = Kokkos::subview(x, k-1, Kokkos::ALL()); + auto x1 = Kokkos::subview(x, k, Kokkos::ALL()); + + auto bk = Kokkos::subview(b, k, Kokkos::ALL()); + auto rk = Kokkos::subview(r, k, Kokkos::ALL()); + TeamCopy + ::invoke(member, bk, rk); + member.team_barrier(); + TeamGemv + ::invoke(member, -1.0, C0, x0, 1.0, rk); + TeamGemv + ::invoke(member, -1.0, A1, x1, 1.0, rk); + } + } + } + }); + }); + Kokkos::fence(); + auto rs_host = Kokkos::create_mirror_view(rs); + auto bs_host = Kokkos::create_mirror_view(bs); + Kokkos::deep_copy(rs_host, rs); + Kokkos::deep_copy(bs_host, bs); + Kokkos::fence(); + { + double norm2 = 0, diff2 = 0; + for (int i0=0;i0; + using member_type = typename policy_type::member_type; policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); Kokkos::parallel_for ("setTridiagToIdentity", - policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + policy, KOKKOS_LAMBDA(const member_type &member) { const int i = member.league_rank(); Kokkos::parallel_for(Kokkos::TeamThreadRange(member,AA.extent(1)),[&](const int &j) { Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { @@ -255,11 +256,12 @@ int main(int argc, char* argv[]) { #endif timer.reset(); using policy_type = Kokkos::TeamPolicy; + using member_type = typename policy_type::member_type; policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); Kokkos::parallel_for ("factorize", policy.set_scratch_size(0,Kokkos::PerTeam(S)), - KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + KOKKOS_LAMBDA(const member_type &member) { typedef FactorizeModeAndAlgo default_mode_and_algo_type; typedef default_mode_and_algo_type::mode_type mode_type; typedef default_mode_and_algo_type::algo_type algo_type; @@ -277,7 +279,7 @@ int main(int argc, char* argv[]) { if (L == 1) { A.assign_data( &AAA(0, 1, 0, 0) ); - LU::invoke(member, A); } else { for (int k=0;k<(L-1);++k) { @@ -286,23 +288,23 @@ int main(int argc, char* argv[]) { C.assign_data( &AAA(k, 0, 0, 0) ); D.assign_data( &AAA(k+1, 1, 0, 0) ); - LU ::invoke(member, A); - Trsm ::invoke(member, 1.0, A, B); - Trsm ::invoke(member, 1.0, A, C); - Gemm ::invoke(member, -1.0, C, B, 1.0, D); } - LU ::invoke(member, D); } @@ -326,11 +328,12 @@ int main(int argc, char* argv[]) { timer.reset(); typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; + using member_type = typename policy_type::member_type; policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); for (int iter=0;iter default_mode_and_algo_type; typedef default_mode_and_algo_type::mode_type mode_type; typedef default_mode_and_algo_type::algo_type algo_type; @@ -359,7 +362,7 @@ int main(int argc, char* argv[]) { auto bk = Kokkos::subview(b, 0, Kokkos::ALL()); { {//if (!is_same_x_and_b) { - Copy ::invoke(member, bk, xb); @@ -376,18 +379,18 @@ int main(int argc, char* argv[]) { { //if (!is_same_x_and_b) { bk.assign_data(&b(k+1, 0)); - Copy ::invoke(member, bk, xb); } - Trsv ::invoke(member, 1.0, LT, xt); - Gemv ::invoke(member, -1.0, LB, xt, 1.0, xb); @@ -395,7 +398,7 @@ int main(int argc, char* argv[]) { { LT.assign_data(&A(kend, 0, 0)); xt.assign_data(&x(kend, 0)); - Trsv ::invoke(member, 1.0, LT, xt); @@ -417,12 +420,12 @@ int main(int argc, char* argv[]) { xt.assign_data(&x(k-1, 0, 0)); xb.assign_data(&x(k, 0, 0)); - Trsv ::invoke(member, 1.0, UB, xb); - Gemv ::invoke(member, -1.0, UT, xb, 1.0, xt); @@ -430,7 +433,7 @@ int main(int argc, char* argv[]) { { UB.assign_data(&A(0, 0, 0)); xb.assign_data(&x(0, 0)); - Trsv ::invoke(member, 1.0, UB, xb); @@ -451,13 +454,14 @@ int main(int argc, char* argv[]) { /// /// compute residual /// - { + if (0) { typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; + using member_type = typename policy_type::member_type; policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); Kokkos::parallel_for ("compute residual", - policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + policy, KOKKOS_LAMBDA(const member_type &member) { const int i = member.league_rank(); Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, Acopy.extent(5)),[&](const int &v) { auto A = Kokkos::subview(Acopy, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); @@ -475,10 +479,10 @@ int main(int argc, char* argv[]) { auto b0 = Kokkos::subview(b, 0, Kokkos::ALL()); auto r0 = Kokkos::subview(r, 0, Kokkos::ALL()); - TeamCopy ::invoke(member, b0, r0); - TeamGemv ::invoke(member, -1.0, A0, x0, 1.0, r0); } else { @@ -493,14 +497,14 @@ int main(int argc, char* argv[]) { auto bk = Kokkos::subview(b, k, Kokkos::ALL()); auto rk = Kokkos::subview(r, k, Kokkos::ALL()); - TeamCopy ::invoke(member, bk, rk); member.team_barrier(); - TeamGemv ::invoke(member, -1.0, A1, x1, 1.0, rk); - TeamGemv ::invoke(member, -1.0, B2, x2, 1.0, rk); ++k; @@ -516,17 +520,17 @@ int main(int argc, char* argv[]) { auto bk = Kokkos::subview(b, k, Kokkos::ALL()); auto rk = Kokkos::subview(r, k, Kokkos::ALL()); - TeamCopy ::invoke(member, bk, rk); member.team_barrier(); - TeamGemv ::invoke(member, -1.0, C0, x0, 1.0, rk); - TeamGemv ::invoke(member, -1.0, A1, x1, 1.0, rk); - TeamGemv ::invoke(member, -1.0, B2, x2, 1.0, rk); } @@ -540,14 +544,14 @@ int main(int argc, char* argv[]) { auto bk = Kokkos::subview(b, k, Kokkos::ALL()); auto rk = Kokkos::subview(r, k, Kokkos::ALL()); - TeamCopy ::invoke(member, bk, rk); member.team_barrier(); - TeamGemv ::invoke(member, -1.0, C0, x0, 1.0, rk); - TeamGemv + TeamGemv ::invoke(member, -1.0, A1, x1, 1.0, rk); } } diff --git a/src/batched/KokkosBatched_SetIdentity_Decl.hpp b/src/batched/KokkosBatched_SetIdentity_Decl.hpp index 64100bd826..338a1558c6 100644 --- a/src/batched/KokkosBatched_SetIdentity_Decl.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Decl.hpp @@ -34,6 +34,28 @@ namespace KokkosBatched { const AViewType &A); }; + + /// + /// Selective Interface + /// + template + struct SetIdentity { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialSetIdentity::invoke(A); + } else if (std::is_same::value) { + r_val = TeamSetIdentity::invoke(member, A); + } + return r_val; + } + }; + } } From 79d0efe335fc4fe4a7750cb7591efb3e6c3ac716 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 21 Feb 2019 10:27:46 -0700 Subject: [PATCH 132/190] KokkosBlas - matched trilinos PR 4444 --- unit_test/CMakeLists.txt | 16 +++++------ unit_test/blas/Test_Blas1_abs.hpp | 12 ++++---- unit_test/blas/Test_Blas1_asum.hpp | 6 ++-- unit_test/blas/Test_Blas1_axpy.hpp | 12 ++++---- unit_test/blas/Test_Blas1_dot.hpp | 12 ++++---- unit_test/blas/Test_Blas1_mult.hpp | 12 ++++---- unit_test/blas/Test_Blas1_nrm2.hpp | 12 ++++---- unit_test/blas/Test_Blas1_nrm2_squared.hpp | 12 ++++---- unit_test/blas/Test_Blas1_nrminf.hpp | 12 ++++---- unit_test/blas/Test_Blas1_reciprocal.hpp | 12 ++++---- unit_test/blas/Test_Blas1_scal.hpp | 12 ++++---- unit_test/blas/Test_Blas1_sum.hpp | 12 ++++---- unit_test/blas/Test_Blas1_team_abs.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_axpby.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_axpy.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_dot.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_mult.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_nrm2.hpp | 12 ++++---- unit_test/blas/Test_Blas1_team_scal.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_team_update.hpp | 32 +++++++++++----------- unit_test/blas/Test_Blas1_update.hpp | 6 ++-- unit_test/blas/Test_Blas2_gemv.hpp | 6 ++-- unit_test/blas/Test_Blas2_team_gemv.hpp | 16 +++++------ unit_test/blas/Test_Blas3_gemm.hpp | 4 +-- 24 files changed, 205 insertions(+), 205 deletions(-) diff --git a/unit_test/CMakeLists.txt b/unit_test/CMakeLists.txt index 3155d6d0a6..96b24035f6 100644 --- a/unit_test/CMakeLists.txt +++ b/unit_test/CMakeLists.txt @@ -90,16 +90,16 @@ IF (Kokkos_ENABLE_OpenMP) APPEND_GLOB(OPENMP_BLAS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/openmp/Test_OpenMP_Blas*.cpp) - IF (KOKKOS_ENABLE_DEBUG) - SET(DISABLE_SLOW_DGEMM_DOUBLE_TEST "--gtest_filter=-openmp.gemm_double") - ENDIF() + # IF (KOKKOS_ENABLE_DEBUG) + # SET(DISABLE_SLOW_DGEMM_DOUBLE_TEST "--gtest_filter=-openmp.gemm_double") + # ENDIF() TRIBITS_ADD_EXECUTABLE_AND_TEST( blas_openmp SOURCES Test_Main.cpp ${OPENMP_BLAS_SOURCES} - ARGS ${DISABLE_SLOW_DGEMM_DOUBLE_TEST} +# ARGS ${DISABLE_SLOW_DGEMM_DOUBLE_TEST} COMM serial mpi NUM_MPI_PROCS 1 TESTONLYLIBS kokkoskernels_gtest @@ -146,16 +146,16 @@ IF (Kokkos_ENABLE_Serial) APPEND_GLOB(SERIAL_BLAS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/serial/Test_Serial_Blas*.cpp) - IF (KOKKOS_ENABLE_DEBUG) - SET(DISABLE_SLOW_DGEMM_DOUBLE_TEST "--gtest_filter=-serial.gemm_double") - ENDIF() + # IF (KOKKOS_ENABLE_DEBUG) + # SET(DISABLE_SLOW_DGEMM_DOUBLE_TEST "--gtest_filter=-serial.gemm_double") + # ENDIF() TRIBITS_ADD_EXECUTABLE_AND_TEST( blas_serial SOURCES Test_Main.cpp ${SERIAL_BLAS_SOURCES} - ARGS ${DISABLE_SLOW_DGEMM_DOUBLE_TEST} +# ARGS ${DISABLE_SLOW_DGEMM_DOUBLE_TEST} COMM serial mpi NUM_MPI_PROCS 1 TESTONLYLIBS kokkoskernels_gtest diff --git a/unit_test/blas/Test_Blas1_abs.hpp b/unit_test/blas/Test_Blas1_abs.hpp index aca3936cd3..acdb167d1d 100644 --- a/unit_test/blas/Test_Blas1_abs.hpp +++ b/unit_test/blas/Test_Blas1_abs.hpp @@ -153,7 +153,7 @@ int test_abs() { Test::impl_test_abs(0); Test::impl_test_abs(13); Test::impl_test_abs(1024); - Test::impl_test_abs(132231); + //Test::impl_test_abs(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -162,7 +162,7 @@ int test_abs() { Test::impl_test_abs(0); Test::impl_test_abs(13); Test::impl_test_abs(1024); - Test::impl_test_abs(132231); + //Test::impl_test_abs(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -171,7 +171,7 @@ int test_abs() { Test::impl_test_abs(0); Test::impl_test_abs(13); Test::impl_test_abs(1024); - Test::impl_test_abs(132231); + //Test::impl_test_abs(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -191,7 +191,7 @@ int test_abs_mv() { Test::impl_test_abs_mv(0,5); Test::impl_test_abs_mv(13,5); Test::impl_test_abs_mv(1024,5); - Test::impl_test_abs_mv(132231,5); + //Test::impl_test_abs_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -200,7 +200,7 @@ int test_abs_mv() { Test::impl_test_abs_mv(0,5); Test::impl_test_abs_mv(13,5); Test::impl_test_abs_mv(1024,5); - Test::impl_test_abs_mv(132231,5); + //Test::impl_test_abs_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -209,7 +209,7 @@ int test_abs_mv() { Test::impl_test_abs_mv(0,5); Test::impl_test_abs_mv(13,5); Test::impl_test_abs_mv(1024,5); - Test::impl_test_abs_mv(132231,5); + //Test::impl_test_abs_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_asum.hpp b/unit_test/blas/Test_Blas1_asum.hpp index bfdfa888f1..82f0341d50 100644 --- a/unit_test/blas/Test_Blas1_asum.hpp +++ b/unit_test/blas/Test_Blas1_asum.hpp @@ -57,7 +57,7 @@ int test_asum() { Test::impl_test_asum(0); Test::impl_test_asum(13); Test::impl_test_asum(1024); - Test::impl_test_asum(132231); + //Test::impl_test_asum(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -65,7 +65,7 @@ int test_asum() { Test::impl_test_asum(0); Test::impl_test_asum(13); Test::impl_test_asum(1024); - Test::impl_test_asum(132231); + //Test::impl_test_asum(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -73,7 +73,7 @@ int test_asum() { Test::impl_test_asum(0); Test::impl_test_asum(13); Test::impl_test_asum(1024); - Test::impl_test_asum(132231); + //Test::impl_test_asum(132231); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_axpy.hpp b/unit_test/blas/Test_Blas1_axpy.hpp index bbe586085d..55841bb5ad 100644 --- a/unit_test/blas/Test_Blas1_axpy.hpp +++ b/unit_test/blas/Test_Blas1_axpy.hpp @@ -144,7 +144,7 @@ int test_axpy() { Test::impl_test_axpy(0); Test::impl_test_axpy(13); Test::impl_test_axpy(1024); - Test::impl_test_axpy(132231); + //Test::impl_test_axpy(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -153,7 +153,7 @@ int test_axpy() { Test::impl_test_axpy(0); Test::impl_test_axpy(13); Test::impl_test_axpy(1024); - Test::impl_test_axpy(132231); + //Test::impl_test_axpy(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -162,7 +162,7 @@ int test_axpy() { Test::impl_test_axpy(0); Test::impl_test_axpy(13); Test::impl_test_axpy(1024); - Test::impl_test_axpy(132231); + //Test::impl_test_axpy(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -182,7 +182,7 @@ int test_axpy_mv() { Test::impl_test_axpy_mv(0,5); Test::impl_test_axpy_mv(13,5); Test::impl_test_axpy_mv(1024,5); - Test::impl_test_axpy_mv(132231,5); + //Test::impl_test_axpy_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -191,7 +191,7 @@ int test_axpy_mv() { Test::impl_test_axpy_mv(0,5); Test::impl_test_axpy_mv(13,5); Test::impl_test_axpy_mv(1024,5); - Test::impl_test_axpy_mv(132231,5); + //Test::impl_test_axpy_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -200,7 +200,7 @@ int test_axpy_mv() { Test::impl_test_axpy_mv(0,5); Test::impl_test_axpy_mv(13,5); Test::impl_test_axpy_mv(1024,5); - Test::impl_test_axpy_mv(132231,5); + //Test::impl_test_axpy_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_dot.hpp b/unit_test/blas/Test_Blas1_dot.hpp index 87b7122328..748be08f9e 100644 --- a/unit_test/blas/Test_Blas1_dot.hpp +++ b/unit_test/blas/Test_Blas1_dot.hpp @@ -151,7 +151,7 @@ int test_dot() { Test::impl_test_dot(0); Test::impl_test_dot(13); Test::impl_test_dot(1024); - Test::impl_test_dot(132231); + //Test::impl_test_dot(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -160,7 +160,7 @@ int test_dot() { Test::impl_test_dot(0); Test::impl_test_dot(13); Test::impl_test_dot(1024); - Test::impl_test_dot(132231); + //Test::impl_test_dot(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -169,7 +169,7 @@ int test_dot() { Test::impl_test_dot(0); Test::impl_test_dot(13); Test::impl_test_dot(1024); - Test::impl_test_dot(132231); + //Test::impl_test_dot(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -189,7 +189,7 @@ int test_dot_mv() { Test::impl_test_dot_mv(0,5); Test::impl_test_dot_mv(13,5); Test::impl_test_dot_mv(1024,5); - Test::impl_test_dot_mv(132231,5); + //Test::impl_test_dot_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -198,7 +198,7 @@ int test_dot_mv() { Test::impl_test_dot_mv(0,5); Test::impl_test_dot_mv(13,5); Test::impl_test_dot_mv(1024,5); - Test::impl_test_dot_mv(132231,5); + //Test::impl_test_dot_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -207,7 +207,7 @@ int test_dot_mv() { Test::impl_test_dot_mv(0,5); Test::impl_test_dot_mv(13,5); Test::impl_test_dot_mv(1024,5); - Test::impl_test_dot_mv(132231,5); + //Test::impl_test_dot_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_mult.hpp b/unit_test/blas/Test_Blas1_mult.hpp index 4e760cd29f..fcab767dcc 100644 --- a/unit_test/blas/Test_Blas1_mult.hpp +++ b/unit_test/blas/Test_Blas1_mult.hpp @@ -175,7 +175,7 @@ int test_mult() { Test::impl_test_mult(0); Test::impl_test_mult(13); Test::impl_test_mult(1024); - Test::impl_test_mult(132231); + //Test::impl_test_mult(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -185,7 +185,7 @@ int test_mult() { Test::impl_test_mult(0); Test::impl_test_mult(13); Test::impl_test_mult(1024); - Test::impl_test_mult(132231); + //Test::impl_test_mult(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -195,7 +195,7 @@ int test_mult() { Test::impl_test_mult(0); Test::impl_test_mult(13); Test::impl_test_mult(1024); - Test::impl_test_mult(132231); + //Test::impl_test_mult(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -216,7 +216,7 @@ int test_mult_mv() { Test::impl_test_mult_mv(0,5); Test::impl_test_mult_mv(13,5); Test::impl_test_mult_mv(1024,5); - Test::impl_test_mult_mv(132231,5); + //Test::impl_test_mult_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -226,7 +226,7 @@ int test_mult_mv() { Test::impl_test_mult_mv(0,5); Test::impl_test_mult_mv(13,5); Test::impl_test_mult_mv(1024,5); - Test::impl_test_mult_mv(132231,5); + //Test::impl_test_mult_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -236,7 +236,7 @@ int test_mult_mv() { Test::impl_test_mult_mv(0,5); Test::impl_test_mult_mv(13,5); Test::impl_test_mult_mv(1024,5); - Test::impl_test_mult_mv(132231,5); + //Test::impl_test_mult_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_nrm2.hpp b/unit_test/blas/Test_Blas1_nrm2.hpp index 699c1aa806..49654d5de8 100644 --- a/unit_test/blas/Test_Blas1_nrm2.hpp +++ b/unit_test/blas/Test_Blas1_nrm2.hpp @@ -113,7 +113,7 @@ int test_nrm2() { Test::impl_test_nrm2(0); Test::impl_test_nrm2(13); Test::impl_test_nrm2(1024); - Test::impl_test_nrm2(132231); + //Test::impl_test_nrm2(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -121,7 +121,7 @@ int test_nrm2() { Test::impl_test_nrm2(0); Test::impl_test_nrm2(13); Test::impl_test_nrm2(1024); - Test::impl_test_nrm2(132231); + //Test::impl_test_nrm2(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -129,7 +129,7 @@ int test_nrm2() { Test::impl_test_nrm2(0); Test::impl_test_nrm2(13); Test::impl_test_nrm2(1024); - Test::impl_test_nrm2(132231); + //Test::impl_test_nrm2(132231); #endif return 1; @@ -143,7 +143,7 @@ int test_nrm2_mv() { Test::impl_test_nrm2_mv(0,5); Test::impl_test_nrm2_mv(13,5); Test::impl_test_nrm2_mv(1024,5); - Test::impl_test_nrm2_mv(132231,5); + //Test::impl_test_nrm2_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -151,7 +151,7 @@ int test_nrm2_mv() { Test::impl_test_nrm2_mv(0,5); Test::impl_test_nrm2_mv(13,5); Test::impl_test_nrm2_mv(1024,5); - Test::impl_test_nrm2_mv(132231,5); + //Test::impl_test_nrm2_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -159,7 +159,7 @@ int test_nrm2_mv() { Test::impl_test_nrm2_mv(0,5); Test::impl_test_nrm2_mv(13,5); Test::impl_test_nrm2_mv(1024,5); - Test::impl_test_nrm2_mv(132231,5); + //Test::impl_test_nrm2_mv(132231,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_nrm2_squared.hpp b/unit_test/blas/Test_Blas1_nrm2_squared.hpp index 5af85a7284..ac116b8987 100644 --- a/unit_test/blas/Test_Blas1_nrm2_squared.hpp +++ b/unit_test/blas/Test_Blas1_nrm2_squared.hpp @@ -117,7 +117,7 @@ int test_nrm2_squared() { Test::impl_test_nrm2_squared(0); Test::impl_test_nrm2_squared(13); Test::impl_test_nrm2_squared(1024); - Test::impl_test_nrm2_squared(132231); + //Test::impl_test_nrm2_squared(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -125,7 +125,7 @@ int test_nrm2_squared() { Test::impl_test_nrm2_squared(0); Test::impl_test_nrm2_squared(13); Test::impl_test_nrm2_squared(1024); - Test::impl_test_nrm2_squared(132231); + //Test::impl_test_nrm2_squared(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -133,7 +133,7 @@ int test_nrm2_squared() { Test::impl_test_nrm2_squared(0); Test::impl_test_nrm2_squared(13); Test::impl_test_nrm2_squared(1024); - Test::impl_test_nrm2_squared(132231); + //Test::impl_test_nrm2_squared(132231); #endif return 1; @@ -147,7 +147,7 @@ int test_nrm2_squared_mv() { Test::impl_test_nrm2_squared_mv(0,5); Test::impl_test_nrm2_squared_mv(13,5); Test::impl_test_nrm2_squared_mv(1024,5); - Test::impl_test_nrm2_squared_mv(132231,5); + //Test::impl_test_nrm2_squared_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -155,7 +155,7 @@ int test_nrm2_squared_mv() { Test::impl_test_nrm2_squared_mv(0,5); Test::impl_test_nrm2_squared_mv(13,5); Test::impl_test_nrm2_squared_mv(1024,5); - Test::impl_test_nrm2_squared_mv(132231,5); + //Test::impl_test_nrm2_squared_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -163,7 +163,7 @@ int test_nrm2_squared_mv() { Test::impl_test_nrm2_squared_mv(0,5); Test::impl_test_nrm2_squared_mv(13,5); Test::impl_test_nrm2_squared_mv(1024,5); - Test::impl_test_nrm2_squared_mv(132231,5); + //Test::impl_test_nrm2_squared_mv(132231,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_nrminf.hpp b/unit_test/blas/Test_Blas1_nrminf.hpp index e1b0f6a238..f328a720b7 100644 --- a/unit_test/blas/Test_Blas1_nrminf.hpp +++ b/unit_test/blas/Test_Blas1_nrminf.hpp @@ -117,7 +117,7 @@ int test_nrminf() { Test::impl_test_nrminf(0); Test::impl_test_nrminf(13); Test::impl_test_nrminf(1024); - Test::impl_test_nrminf(132231); + //Test::impl_test_nrminf(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -125,7 +125,7 @@ int test_nrminf() { Test::impl_test_nrminf(0); Test::impl_test_nrminf(13); Test::impl_test_nrminf(1024); - Test::impl_test_nrminf(132231); + //Test::impl_test_nrminf(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -133,7 +133,7 @@ int test_nrminf() { Test::impl_test_nrminf(0); Test::impl_test_nrminf(13); Test::impl_test_nrminf(1024); - Test::impl_test_nrminf(132231); + //Test::impl_test_nrminf(132231); #endif return 1; @@ -147,7 +147,7 @@ int test_nrminf_mv() { Test::impl_test_nrminf_mv(0,5); Test::impl_test_nrminf_mv(13,5); Test::impl_test_nrminf_mv(1024,5); - Test::impl_test_nrminf_mv(132231,5); + //Test::impl_test_nrminf_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -155,7 +155,7 @@ int test_nrminf_mv() { Test::impl_test_nrminf_mv(0,5); Test::impl_test_nrminf_mv(13,5); Test::impl_test_nrminf_mv(1024,5); - Test::impl_test_nrminf_mv(132231,5); + //Test::impl_test_nrminf_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -163,7 +163,7 @@ int test_nrminf_mv() { Test::impl_test_nrminf_mv(0,5); Test::impl_test_nrminf_mv(13,5); Test::impl_test_nrminf_mv(1024,5); - Test::impl_test_nrminf_mv(132231,5); + //Test::impl_test_nrminf_mv(132231,5); #endif return 1;} diff --git a/unit_test/blas/Test_Blas1_reciprocal.hpp b/unit_test/blas/Test_Blas1_reciprocal.hpp index b0e4ad6b80..b19e368a64 100644 --- a/unit_test/blas/Test_Blas1_reciprocal.hpp +++ b/unit_test/blas/Test_Blas1_reciprocal.hpp @@ -158,7 +158,7 @@ int test_reciprocal() { Test::impl_test_reciprocal(0); Test::impl_test_reciprocal(13); Test::impl_test_reciprocal(1024); - Test::impl_test_reciprocal(132231); + //Test::impl_test_reciprocal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -167,7 +167,7 @@ int test_reciprocal() { Test::impl_test_reciprocal(0); Test::impl_test_reciprocal(13); Test::impl_test_reciprocal(1024); - Test::impl_test_reciprocal(132231); + //Test::impl_test_reciprocal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -176,7 +176,7 @@ int test_reciprocal() { Test::impl_test_reciprocal(0); Test::impl_test_reciprocal(13); Test::impl_test_reciprocal(1024); - Test::impl_test_reciprocal(132231); + //Test::impl_test_reciprocal(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -196,7 +196,7 @@ int test_reciprocal_mv() { Test::impl_test_reciprocal_mv(0,5); Test::impl_test_reciprocal_mv(13,5); Test::impl_test_reciprocal_mv(1024,5); - Test::impl_test_reciprocal_mv(132231,5); + //Test::impl_test_reciprocal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -205,7 +205,7 @@ int test_reciprocal_mv() { Test::impl_test_reciprocal_mv(0,5); Test::impl_test_reciprocal_mv(13,5); Test::impl_test_reciprocal_mv(1024,5); - Test::impl_test_reciprocal_mv(132231,5); + //Test::impl_test_reciprocal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -214,7 +214,7 @@ int test_reciprocal_mv() { Test::impl_test_reciprocal_mv(0,5); Test::impl_test_reciprocal_mv(13,5); Test::impl_test_reciprocal_mv(1024,5); - Test::impl_test_reciprocal_mv(132231,5); + //Test::impl_test_reciprocal_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_scal.hpp b/unit_test/blas/Test_Blas1_scal.hpp index fd406767ea..f59b8d49ea 100644 --- a/unit_test/blas/Test_Blas1_scal.hpp +++ b/unit_test/blas/Test_Blas1_scal.hpp @@ -199,7 +199,7 @@ int test_scal() { Test::impl_test_scal(0); Test::impl_test_scal(13); Test::impl_test_scal(1024); - Test::impl_test_scal(132231); + //Test::impl_test_scal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -208,7 +208,7 @@ int test_scal() { Test::impl_test_scal(0); Test::impl_test_scal(13); Test::impl_test_scal(1024); - Test::impl_test_scal(132231); + //Test::impl_test_scal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -217,7 +217,7 @@ int test_scal() { Test::impl_test_scal(0); Test::impl_test_scal(13); Test::impl_test_scal(1024); - Test::impl_test_scal(132231); + //Test::impl_test_scal(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) @@ -237,7 +237,7 @@ int test_scal_mv() { Test::impl_test_scal_mv(0,5); Test::impl_test_scal_mv(13,5); Test::impl_test_scal_mv(1024,5); - Test::impl_test_scal_mv(132231,5); + //Test::impl_test_scal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -246,7 +246,7 @@ int test_scal_mv() { Test::impl_test_scal_mv(0,5); Test::impl_test_scal_mv(13,5); Test::impl_test_scal_mv(1024,5); - Test::impl_test_scal_mv(132231,5); + //Test::impl_test_scal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -255,7 +255,7 @@ int test_scal_mv() { Test::impl_test_scal_mv(0,5); Test::impl_test_scal_mv(13,5); Test::impl_test_scal_mv(1024,5); - Test::impl_test_scal_mv(132231,5); + //Test::impl_test_scal_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas1_sum.hpp b/unit_test/blas/Test_Blas1_sum.hpp index bd345a5666..adbb95f246 100644 --- a/unit_test/blas/Test_Blas1_sum.hpp +++ b/unit_test/blas/Test_Blas1_sum.hpp @@ -110,7 +110,7 @@ int test_sum() { Test::impl_test_sum(0); Test::impl_test_sum(13); Test::impl_test_sum(1024); - Test::impl_test_sum(132231); + //Test::impl_test_sum(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -118,7 +118,7 @@ int test_sum() { Test::impl_test_sum(0); Test::impl_test_sum(13); Test::impl_test_sum(1024); - Test::impl_test_sum(132231); + //Test::impl_test_sum(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -126,7 +126,7 @@ int test_sum() { Test::impl_test_sum(0); Test::impl_test_sum(13); Test::impl_test_sum(1024); - Test::impl_test_sum(132231); + //Test::impl_test_sum(132231); #endif return 1; @@ -140,7 +140,7 @@ int test_sum_mv() { Test::impl_test_sum_mv(0,5); Test::impl_test_sum_mv(13,5); Test::impl_test_sum_mv(1024,5); - Test::impl_test_sum_mv(132231,5); + //Test::impl_test_sum_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -148,7 +148,7 @@ int test_sum_mv() { Test::impl_test_sum_mv(0,5); Test::impl_test_sum_mv(13,5); Test::impl_test_sum_mv(1024,5); - Test::impl_test_sum_mv(132231,5); + //Test::impl_test_sum_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -156,7 +156,7 @@ int test_sum_mv() { Test::impl_test_sum_mv(0,5); Test::impl_test_sum_mv(13,5); Test::impl_test_sum_mv(1024,5); - Test::impl_test_sum_mv(132231,5); + //Test::impl_test_sum_mv(132231,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_abs.hpp b/unit_test/blas/Test_Blas1_team_abs.hpp index ca89b2c090..87ebef5065 100644 --- a/unit_test/blas/Test_Blas1_team_abs.hpp +++ b/unit_test/blas/Test_Blas1_team_abs.hpp @@ -187,8 +187,8 @@ int test_team_abs() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_abs(0); Test::impl_test_team_abs(13); - Test::impl_test_team_abs(1024); - Test::impl_test_team_abs(132231); + Test::impl_test_team_abs(124); + //Test::impl_test_team_abs(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -196,8 +196,8 @@ int test_team_abs() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_abs(0); Test::impl_test_team_abs(13); - Test::impl_test_team_abs(1024); - Test::impl_test_team_abs(132231); + Test::impl_test_team_abs(124); + //Test::impl_test_team_abs(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -205,13 +205,13 @@ int test_team_abs() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_abs(0); Test::impl_test_team_abs(13); - Test::impl_test_team_abs(1024); - Test::impl_test_team_abs(132231); + Test::impl_test_team_abs(124); + //Test::impl_test_team_abs(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_abs(1024); - Test::impl_test_team_abs(1024); + Test::impl_test_team_abs(124); + Test::impl_test_team_abs(124); #endif return 1; @@ -225,8 +225,8 @@ int test_team_abs_mv() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_abs_mv(0,5); Test::impl_test_team_abs_mv(13,5); - Test::impl_test_team_abs_mv(1024,5); - Test::impl_test_team_abs_mv(132231,5); + Test::impl_test_team_abs_mv(124,5); + //Test::impl_test_team_abs_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -234,8 +234,8 @@ int test_team_abs_mv() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_abs_mv(0,5); Test::impl_test_team_abs_mv(13,5); - Test::impl_test_team_abs_mv(1024,5); - Test::impl_test_team_abs_mv(132231,5); + Test::impl_test_team_abs_mv(124,5); + //Test::impl_test_team_abs_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -243,13 +243,13 @@ int test_team_abs_mv() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_abs_mv(0,5); Test::impl_test_team_abs_mv(13,5); - Test::impl_test_team_abs_mv(1024,5); - Test::impl_test_team_abs_mv(132231,5); + Test::impl_test_team_abs_mv(124,5); + //Test::impl_test_team_abs_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_abs_mv(1024,5); - Test::impl_test_team_abs_mv(1024,5); + Test::impl_test_team_abs_mv(124,5); + Test::impl_test_team_abs_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_axpby.hpp b/unit_test/blas/Test_Blas1_team_axpby.hpp index b0aa24cbe6..7e8d9eac10 100644 --- a/unit_test/blas/Test_Blas1_team_axpby.hpp +++ b/unit_test/blas/Test_Blas1_team_axpby.hpp @@ -184,8 +184,8 @@ int test_team_axpby() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_axpby(0); Test::impl_test_team_axpby(13); - Test::impl_test_team_axpby(1024); - Test::impl_test_team_axpby(132231); + Test::impl_test_team_axpby(124); + //Test::impl_test_team_axpby(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -193,8 +193,8 @@ int test_team_axpby() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_axpby(0); Test::impl_test_team_axpby(13); - Test::impl_test_team_axpby(1024); - Test::impl_test_team_axpby(132231); + Test::impl_test_team_axpby(124); + //Test::impl_test_team_axpby(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -202,13 +202,13 @@ int test_team_axpby() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_axpby(0); Test::impl_test_team_axpby(13); - Test::impl_test_team_axpby(1024); - Test::impl_test_team_axpby(132231); + Test::impl_test_team_axpby(124); + //Test::impl_test_team_axpby(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_axpby(1024); - Test::impl_test_team_axpby(1024); + Test::impl_test_team_axpby(124); + Test::impl_test_team_axpby(124); #endif return 1; @@ -222,8 +222,8 @@ int test_team_axpby_mv() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_axpby_mv(0,5); Test::impl_test_team_axpby_mv(13,5); - Test::impl_test_team_axpby_mv(1024,5); - Test::impl_test_team_axpby_mv(132231,5); + Test::impl_test_team_axpby_mv(124,5); + //Test::impl_test_team_axpby_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -231,8 +231,8 @@ int test_team_axpby_mv() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_axpby_mv(0,5); Test::impl_test_team_axpby_mv(13,5); - Test::impl_test_team_axpby_mv(1024,5); - Test::impl_test_team_axpby_mv(132231,5); + Test::impl_test_team_axpby_mv(124,5); + //Test::impl_test_team_axpby_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -240,13 +240,13 @@ int test_team_axpby_mv() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_axpby_mv(0,5); Test::impl_test_team_axpby_mv(13,5); - Test::impl_test_team_axpby_mv(1024,5); - Test::impl_test_team_axpby_mv(132231,5); + Test::impl_test_team_axpby_mv(124,5); + //Test::impl_test_team_axpby_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_axpby_mv(1024,5); - Test::impl_test_team_axpby_mv(1024,5); + Test::impl_test_team_axpby_mv(124,5); + Test::impl_test_team_axpby_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_axpy.hpp b/unit_test/blas/Test_Blas1_team_axpy.hpp index eba3e51eab..507e7b4a01 100644 --- a/unit_test/blas/Test_Blas1_team_axpy.hpp +++ b/unit_test/blas/Test_Blas1_team_axpy.hpp @@ -179,8 +179,8 @@ int test_team_axpy() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_axpy(0); Test::impl_test_team_axpy(13); - Test::impl_test_team_axpy(1024); - Test::impl_test_team_axpy(132231); + Test::impl_test_team_axpy(124); + //Test::impl_test_team_axpy(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -188,8 +188,8 @@ int test_team_axpy() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_axpy(0); Test::impl_test_team_axpy(13); - Test::impl_test_team_axpy(1024); - Test::impl_test_team_axpy(132231); + Test::impl_test_team_axpy(124); + //Test::impl_test_team_axpy(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -197,13 +197,13 @@ int test_team_axpy() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_axpy(0); Test::impl_test_team_axpy(13); - Test::impl_test_team_axpy(1024); - Test::impl_test_team_axpy(132231); + Test::impl_test_team_axpy(124); + //Test::impl_test_team_axpy(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_axpy(1024); - Test::impl_test_team_axpy(1024); + Test::impl_test_team_axpy(124); + Test::impl_test_team_axpy(124); #endif return 1; @@ -217,8 +217,8 @@ int test_team_axpy_mv() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_axpy_mv(0,5); Test::impl_test_team_axpy_mv(13,5); - Test::impl_test_team_axpy_mv(1024,5); - Test::impl_test_team_axpy_mv(132231,5); + Test::impl_test_team_axpy_mv(124,5); + //Test::impl_test_team_axpy_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -226,8 +226,8 @@ int test_team_axpy_mv() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_axpy_mv(0,5); Test::impl_test_team_axpy_mv(13,5); - Test::impl_test_team_axpy_mv(1024,5); - Test::impl_test_team_axpy_mv(132231,5); + Test::impl_test_team_axpy_mv(124,5); + //Test::impl_test_team_axpy_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -235,13 +235,13 @@ int test_team_axpy_mv() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_axpy_mv(0,5); Test::impl_test_team_axpy_mv(13,5); - Test::impl_test_team_axpy_mv(1024,5); - Test::impl_test_team_axpy_mv(132231,5); + Test::impl_test_team_axpy_mv(124,5); + //Test::impl_test_team_axpy_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_axpy_mv(1024,5); - Test::impl_test_team_axpy_mv(1024,5); + Test::impl_test_team_axpy_mv(124,5); + Test::impl_test_team_axpy_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_dot.hpp b/unit_test/blas/Test_Blas1_team_dot.hpp index bac183d4fd..158dcf5733 100644 --- a/unit_test/blas/Test_Blas1_team_dot.hpp +++ b/unit_test/blas/Test_Blas1_team_dot.hpp @@ -226,8 +226,8 @@ int test_team_dot() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_dot(0); Test::impl_test_team_dot(13); - Test::impl_test_team_dot(1024); - Test::impl_test_team_dot(132231); + Test::impl_test_team_dot(124); + //Test::impl_test_team_dot(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -235,8 +235,8 @@ int test_team_dot() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_dot(0); Test::impl_test_team_dot(13); - Test::impl_test_team_dot(1024); - Test::impl_test_team_dot(132231); + Test::impl_test_team_dot(124); + //Test::impl_test_team_dot(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -244,13 +244,13 @@ int test_team_dot() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_dot(0); Test::impl_test_team_dot(13); - Test::impl_test_team_dot(1024); - Test::impl_test_team_dot(132231); + Test::impl_test_team_dot(124); + //Test::impl_test_team_dot(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_dot(1024); - Test::impl_test_team_dot(1024); + Test::impl_test_team_dot(124); + Test::impl_test_team_dot(124); #endif return 1; @@ -264,8 +264,8 @@ int test_team_dot_mv() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_dot_mv(0,5); Test::impl_test_team_dot_mv(13,5); - Test::impl_test_team_dot_mv(1024,5); - Test::impl_test_team_dot_mv(132231,5); + Test::impl_test_team_dot_mv(124,5); + //Test::impl_test_team_dot_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -273,8 +273,8 @@ int test_team_dot_mv() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_dot_mv(0,5); Test::impl_test_team_dot_mv(13,5); - Test::impl_test_team_dot_mv(1024,5); - Test::impl_test_team_dot_mv(132231,5); + Test::impl_test_team_dot_mv(124,5); + //Test::impl_test_team_dot_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -282,13 +282,13 @@ int test_team_dot_mv() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_dot_mv(0,5); Test::impl_test_team_dot_mv(13,5); - Test::impl_test_team_dot_mv(1024,5); - Test::impl_test_team_dot_mv(132231,5); + Test::impl_test_team_dot_mv(124,5); + //Test::impl_test_team_dot_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_dot_mv(1024,5); - Test::impl_test_team_dot_mv(1024,5); + Test::impl_test_team_dot_mv(124,5); + Test::impl_test_team_dot_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_mult.hpp b/unit_test/blas/Test_Blas1_team_mult.hpp index 4c230b1d32..f369e8c137 100644 --- a/unit_test/blas/Test_Blas1_team_mult.hpp +++ b/unit_test/blas/Test_Blas1_team_mult.hpp @@ -208,8 +208,8 @@ int test_team_mult() { typedef Kokkos::View view_type_c_ll; Test::impl_test_team_mult(0); Test::impl_test_team_mult(13); - Test::impl_test_team_mult(1024); - Test::impl_test_team_mult(132231); + Test::impl_test_team_mult(124); + //Test::impl_test_team_mult(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -218,8 +218,8 @@ int test_team_mult() { typedef Kokkos::View view_type_c_lr; Test::impl_test_team_mult(0); Test::impl_test_team_mult(13); - Test::impl_test_team_mult(1024); - Test::impl_test_team_mult(132231); + Test::impl_test_team_mult(124); + //Test::impl_test_team_mult(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -228,13 +228,13 @@ int test_team_mult() { typedef Kokkos::View view_type_c_ls; Test::impl_test_team_mult(0); Test::impl_test_team_mult(13); - Test::impl_test_team_mult(1024); - Test::impl_test_team_mult(132231); + Test::impl_test_team_mult(124); + //Test::impl_test_team_mult(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_mult(1024); - Test::impl_test_team_mult(1024); + Test::impl_test_team_mult(124); + Test::impl_test_team_mult(124); #endif return 1; @@ -249,8 +249,8 @@ int test_team_mult_mv() { typedef Kokkos::View view_type_c_ll; Test::impl_test_team_mult_mv(0,5); Test::impl_test_team_mult_mv(13,5); - Test::impl_test_team_mult_mv(1024,5); - Test::impl_test_team_mult_mv(132231,5); + Test::impl_test_team_mult_mv(124,5); + //Test::impl_test_team_mult_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -259,8 +259,8 @@ int test_team_mult_mv() { typedef Kokkos::View view_type_c_lr; Test::impl_test_team_mult_mv(0,5); Test::impl_test_team_mult_mv(13,5); - Test::impl_test_team_mult_mv(1024,5); - Test::impl_test_team_mult_mv(132231,5); + Test::impl_test_team_mult_mv(124,5); + //Test::impl_test_team_mult_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -269,13 +269,13 @@ int test_team_mult_mv() { typedef Kokkos::View view_type_c_ls; Test::impl_test_team_mult_mv(0,5); Test::impl_test_team_mult_mv(13,5); - Test::impl_test_team_mult_mv(1024,5); - Test::impl_test_team_mult_mv(132231,5); + Test::impl_test_team_mult_mv(124,5); + //Test::impl_test_team_mult_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_mult_mv(1024,5); - Test::impl_test_team_mult_mv(1024,5); + Test::impl_test_team_mult_mv(124,5); + Test::impl_test_team_mult_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_nrm2.hpp b/unit_test/blas/Test_Blas1_team_nrm2.hpp index 7bfb57f96b..4c654c7eae 100644 --- a/unit_test/blas/Test_Blas1_team_nrm2.hpp +++ b/unit_test/blas/Test_Blas1_team_nrm2.hpp @@ -85,24 +85,24 @@ int test_team_nrm2() { typedef Kokkos::View view_type_a_ll; Test::impl_test_team_nrm2(0,5); Test::impl_test_team_nrm2(13,5); - Test::impl_test_team_nrm2(1024,5); - Test::impl_test_team_nrm2(132231,5); + Test::impl_test_team_nrm2(124,5); + //Test::impl_test_team_nrm2(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) typedef Kokkos::View view_type_a_lr; Test::impl_test_team_nrm2(0,5); Test::impl_test_team_nrm2(13,5); - Test::impl_test_team_nrm2(1024,5); - Test::impl_test_team_nrm2(132231,5); + Test::impl_test_team_nrm2(124,5); + //Test::impl_test_team_nrm2(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) typedef Kokkos::View view_type_a_ls; Test::impl_test_team_nrm2(0,5); Test::impl_test_team_nrm2(13,5); - Test::impl_test_team_nrm2(1024,5); - Test::impl_test_team_nrm2(132231,5); + Test::impl_test_team_nrm2(124,5); + //Test::impl_test_team_nrm2(132231,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_scal.hpp b/unit_test/blas/Test_Blas1_team_scal.hpp index 46f61a6ca7..6b33caa262 100644 --- a/unit_test/blas/Test_Blas1_team_scal.hpp +++ b/unit_test/blas/Test_Blas1_team_scal.hpp @@ -239,8 +239,8 @@ int test_team_scal() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_scal(0); Test::impl_test_team_scal(13); - Test::impl_test_team_scal(1024); - Test::impl_test_team_scal(132231); + Test::impl_test_team_scal(124); + //Test::impl_test_team_scal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -248,8 +248,8 @@ int test_team_scal() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_scal(0); Test::impl_test_team_scal(13); - Test::impl_test_team_scal(1024); - Test::impl_test_team_scal(132231); + Test::impl_test_team_scal(124); + //Test::impl_test_team_scal(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -257,13 +257,13 @@ int test_team_scal() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_scal(0); Test::impl_test_team_scal(13); - Test::impl_test_team_scal(1024); - Test::impl_test_team_scal(132231); + Test::impl_test_team_scal(124); + //Test::impl_test_team_scal(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_scal(1024); - Test::impl_test_team_scal(1024); + Test::impl_test_team_scal(124); + Test::impl_test_team_scal(124); #endif return 1; @@ -277,8 +277,8 @@ int test_team_scal_mv() { typedef Kokkos::View view_type_b_ll; Test::impl_test_team_scal_mv(0,5); Test::impl_test_team_scal_mv(13,5); - Test::impl_test_team_scal_mv(1024,5); - Test::impl_test_team_scal_mv(132231,5); + Test::impl_test_team_scal_mv(124,5); + //Test::impl_test_team_scal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -286,8 +286,8 @@ int test_team_scal_mv() { typedef Kokkos::View view_type_b_lr; Test::impl_test_team_scal_mv(0,5); Test::impl_test_team_scal_mv(13,5); - Test::impl_test_team_scal_mv(1024,5); - Test::impl_test_team_scal_mv(132231,5); + Test::impl_test_team_scal_mv(124,5); + //Test::impl_test_team_scal_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -295,13 +295,13 @@ int test_team_scal_mv() { typedef Kokkos::View view_type_b_ls; Test::impl_test_team_scal_mv(0,5); Test::impl_test_team_scal_mv(13,5); - Test::impl_test_team_scal_mv(1024,5); - Test::impl_test_team_scal_mv(132231,5); + Test::impl_test_team_scal_mv(124,5); + //Test::impl_test_team_scal_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_scal_mv(1024,5); - Test::impl_test_team_scal_mv(1024,5); + Test::impl_test_team_scal_mv(124,5); + Test::impl_test_team_scal_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_team_update.hpp b/unit_test/blas/Test_Blas1_team_update.hpp index 9545f42829..dcc9d1e486 100644 --- a/unit_test/blas/Test_Blas1_team_update.hpp +++ b/unit_test/blas/Test_Blas1_team_update.hpp @@ -212,8 +212,8 @@ int test_team_update() { typedef Kokkos::View view_type_c_ll; Test::impl_test_team_update(0); Test::impl_test_team_update(13); - Test::impl_test_team_update(1024); - Test::impl_test_team_update(132231); + Test::impl_test_team_update(124); + //Test::impl_test_team_update(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -222,8 +222,8 @@ int test_team_update() { typedef Kokkos::View view_type_c_lr; Test::impl_test_team_update(0); Test::impl_test_team_update(13); - Test::impl_test_team_update(1024); - Test::impl_test_team_update(132231); + Test::impl_test_team_update(124); + //Test::impl_test_team_update(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -232,13 +232,13 @@ int test_team_update() { typedef Kokkos::View view_type_c_ls; Test::impl_test_team_update(0); Test::impl_test_team_update(13); - Test::impl_test_team_update(1024); - Test::impl_test_team_update(132231); + Test::impl_test_team_update(124); + //Test::impl_test_team_update(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_update(1024); - Test::impl_test_team_update(1024); + Test::impl_test_team_update(124); + Test::impl_test_team_update(124); #endif return 1; @@ -253,8 +253,8 @@ int test_team_update_mv() { typedef Kokkos::View view_type_c_ll; Test::impl_test_team_update_mv(0,5); Test::impl_test_team_update_mv(13,5); - Test::impl_test_team_update_mv(1024,5); - Test::impl_test_team_update_mv(132231,5); + Test::impl_test_team_update_mv(124,5); + //Test::impl_test_team_update_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -263,8 +263,8 @@ int test_team_update_mv() { typedef Kokkos::View view_type_c_lr; Test::impl_test_team_update_mv(0,5); Test::impl_test_team_update_mv(13,5); - Test::impl_test_team_update_mv(1024,5); - Test::impl_test_team_update_mv(132231,5); + Test::impl_test_team_update_mv(124,5); + //Test::impl_test_team_update_mv(132231,5); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -273,13 +273,13 @@ int test_team_update_mv() { typedef Kokkos::View view_type_c_ls; Test::impl_test_team_update_mv(0,5); Test::impl_test_team_update_mv(13,5); - Test::impl_test_team_update_mv(1024,5); - Test::impl_test_team_update_mv(132231,5); + Test::impl_test_team_update_mv(124,5); + //Test::impl_test_team_update_mv(132231,5); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_update_mv(1024,5); - Test::impl_test_team_update_mv(1024,5); + Test::impl_test_team_update_mv(124,5); + Test::impl_test_team_update_mv(124,5); #endif return 1; diff --git a/unit_test/blas/Test_Blas1_update.hpp b/unit_test/blas/Test_Blas1_update.hpp index 70e516c3e8..8bfcdbe5cc 100644 --- a/unit_test/blas/Test_Blas1_update.hpp +++ b/unit_test/blas/Test_Blas1_update.hpp @@ -179,7 +179,7 @@ int test_update() { Test::impl_test_update(0); Test::impl_test_update(13); Test::impl_test_update(1024); - Test::impl_test_update(132231); + //Test::impl_test_update(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -189,7 +189,7 @@ int test_update() { Test::impl_test_update(0); Test::impl_test_update(13); Test::impl_test_update(1024); - Test::impl_test_update(132231); + //Test::impl_test_update(132231); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -199,7 +199,7 @@ int test_update() { Test::impl_test_update(0); Test::impl_test_update(13); Test::impl_test_update(1024); - Test::impl_test_update(132231); + //Test::impl_test_update(132231); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas2_gemv.hpp b/unit_test/blas/Test_Blas2_gemv.hpp index a0b15ce942..294abadd5b 100644 --- a/unit_test/blas/Test_Blas2_gemv.hpp +++ b/unit_test/blas/Test_Blas2_gemv.hpp @@ -104,7 +104,7 @@ int test_gemv(const char* mode) { Test::impl_test_gemv(mode,0,1024); Test::impl_test_gemv(mode,13,1024); Test::impl_test_gemv(mode,1024,1024); - Test::impl_test_gemv(mode,132231,1024); + //Test::impl_test_gemv(mode,132231,1024); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -114,7 +114,7 @@ int test_gemv(const char* mode) { Test::impl_test_gemv(mode,0,1024); Test::impl_test_gemv(mode,13,1024); Test::impl_test_gemv(mode,1024,1024); - Test::impl_test_gemv(mode,132231,1024); + //Test::impl_test_gemv(mode,132231,1024); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -124,7 +124,7 @@ int test_gemv(const char* mode) { Test::impl_test_gemv(mode,0,1024); Test::impl_test_gemv(mode,13,1024); Test::impl_test_gemv(mode,1024,1024); - Test::impl_test_gemv(mode,132231,1024); + //Test::impl_test_gemv(mode,132231,1024); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) diff --git a/unit_test/blas/Test_Blas2_team_gemv.hpp b/unit_test/blas/Test_Blas2_team_gemv.hpp index f0dd70d453..124941bfd8 100644 --- a/unit_test/blas/Test_Blas2_team_gemv.hpp +++ b/unit_test/blas/Test_Blas2_team_gemv.hpp @@ -129,8 +129,8 @@ int test_team_gemv(const char* mode) { typedef Kokkos::View view_type_c_ll; Test::impl_test_team_gemv(mode,0,1024); Test::impl_test_team_gemv(mode,13,1024); - Test::impl_test_team_gemv(mode,1024,1024); - Test::impl_test_team_gemv(mode,132231,1024); + Test::impl_test_team_gemv(mode,124,124); + //Test::impl_test_team_gemv(mode,132231,1024); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -139,8 +139,8 @@ int test_team_gemv(const char* mode) { typedef Kokkos::View view_type_c_lr; Test::impl_test_team_gemv(mode,0,1024); Test::impl_test_team_gemv(mode,13,1024); - Test::impl_test_team_gemv(mode,1024,1024); - Test::impl_test_team_gemv(mode,132231,1024); + Test::impl_test_team_gemv(mode,124,124); + //Test::impl_test_team_gemv(mode,132231,1024); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -149,13 +149,13 @@ int test_team_gemv(const char* mode) { typedef Kokkos::View view_type_c_ls; Test::impl_test_team_gemv(mode,0,1024); Test::impl_test_team_gemv(mode,13,1024); - Test::impl_test_team_gemv(mode,1024,1024); - Test::impl_test_team_gemv(mode,132231,1024); + Test::impl_test_team_gemv(mode,124,124); + //Test::impl_test_team_gemv(mode,132231,1024); #endif #if !defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS) - Test::impl_test_team_gemv(mode,1024,1024); - Test::impl_test_team_gemv(mode,1024,1024); + Test::impl_test_team_gemv(mode,124,124); + Test::impl_test_team_gemv(mode,124,124); #endif return 1; diff --git a/unit_test/blas/Test_Blas3_gemm.hpp b/unit_test/blas/Test_Blas3_gemm.hpp index fd44e8c101..6b4bb0d152 100644 --- a/unit_test/blas/Test_Blas3_gemm.hpp +++ b/unit_test/blas/Test_Blas3_gemm.hpp @@ -162,7 +162,7 @@ int test_gemm(const char* mode, ScalarA alpha, ScalarB beta) { Test::impl_test_gemm(&mode[0],&mode[1],13,15,17,alpha,beta); Test::impl_test_gemm(&mode[0],&mode[1],179,15,211,alpha,beta); Test::impl_test_gemm(&mode[0],&mode[1],12,3071,517,alpha,beta); - Test::impl_test_gemm(&mode[0],&mode[1],1024,1024,2048,alpha,beta); + //Test::impl_test_gemm(&mode[0],&mode[1],1024,1024,2048,alpha,beta); #endif #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) @@ -173,7 +173,7 @@ int test_gemm(const char* mode, ScalarA alpha, ScalarB beta) { Test::impl_test_gemm(&mode[0],&mode[1],13,15,17,alpha,beta); Test::impl_test_gemm(&mode[0],&mode[1],179,15,211,alpha,beta); Test::impl_test_gemm(&mode[0],&mode[1],12,3071,517,alpha,beta); - Test::impl_test_gemm(&mode[0],&mode[1],1024,1024,2048,alpha,beta); + //Test::impl_test_gemm(&mode[0],&mode[1],1024,1024,2048,alpha,beta); #endif /* #if defined(KOKKOSKERNELS_INST_LAYOUTSTRIDE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) From ff8ad68a436a637f7ed7a60528819e6153d573ad Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 21 Feb 2019 17:15:48 -0700 Subject: [PATCH 133/190] KokkosBatched - jacobi version works but slow --- ...osBatched_Test_BlockTridiagAsyncJacobi.cpp | 238 ++++++++---------- .../KokkosBatched_Test_BlockTridiagDirect.cpp | 2 +- 2 files changed, 108 insertions(+), 132 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp index 98a2c9ec73..8aa19c8598 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp @@ -12,6 +12,8 @@ #include #include #include +#include +#include #include #include #include @@ -30,7 +32,7 @@ #include #include -//#define KOKKOSBATCHED_PROFILE 1 +#define KOKKOSBATCHED_PROFILE 1 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) #include "cuda_profiler_api.h" #endif @@ -107,6 +109,7 @@ int main(int argc, char* argv[]) { int Nvec = 1; int S = 0; /// scratch size int niter = 1; + int nsweep = 10; for (int i=1;i yv("y", + N/vector_length, Nvec, L, Blk); + + /// double + Kokkos::View ys((value_type*)yv.data(), + yv.extent(0), + yv.extent(1), + yv.extent(2), + yv.extent(3), + vector_length); + + /// double 2 + Kokkos::View yi((internal_vector_type*)yv.data(), + yv.extent(0), + yv.extent(1), + yv.extent(2), + yv.extent(3), + vector_length/internal_vector_length); + /// double 16 Kokkos::View bv("b", N/vector_length, Nvec, L, Blk); @@ -205,6 +229,7 @@ int main(int argc, char* argv[]) { auto AA = Ai; auto bb = bi; auto xx = xi; + auto yy = yi; // auto AA = As; // auto bb = bs; @@ -225,15 +250,15 @@ int main(int argc, char* argv[]) { #endif using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); Kokkos::parallel_for ("diagonal dominant", - policy, KOKKOS_LAMBDA(const typename policy_type::member_type &member) { - const int i = member.league_rank(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,AA.extent(1)),[&](const int &j) { + policy, KOKKOS_LAMBDA(const member_type &member) { + const int i = member.league_rank()/L; + const int k = member.league_rank()%L; + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,Blk),[&](const int &j) { Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { - for (int k=0;k scratch_view_type; using policy_type = Kokkos::TeamPolicy; + using member_type = typename policy_type::member_type; const int per_team_scratch = scratch_view_type::shmem_size(Blk, Blk, AA.extent(5)); policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); Kokkos::parallel_for ("inverse diagonals", - policy.set_scratch_size(0,Kokkos::PerTeam(S)), - KOKKOS_LAMBDA(const typename policy_type::member_type &member) { + policy.set_scratch_size(0,Kokkos::PerTeam(S < per_team_scratch ? per_team_scratch : S)), + KOKKOS_LAMBDA(const member_type &member) { typedef InverseDiagonalsModeAndAlgo default_mode_and_algo_type; typedef default_mode_and_algo_type::mode_type mode_type; typedef default_mode_and_algo_type::algo_type algo_type; @@ -277,20 +303,21 @@ int main(int argc, char* argv[]) { auto D = Kokkos::subview(AA, i, k, 3, Kokkos::ALL(), Kokkos::ALL(), v); auto W = Kokkos::subview(WW, Kokkos::ALL(), Kokkos::ALL(), v); - Copy ::invoke(member, A, W); - SetIdentity + SetIdentity ::invoke(member, D); - member.barrier(); - LU::invoke(member, W); - Trsm ::invoke(member, 1.0, W, D); - Trsm ::invoke(member, 1.0, W, D); @@ -307,127 +334,76 @@ int main(int argc, char* argv[]) { /// /// solve the matrix 20 times /// - if (0) { + if (1) { #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) cudaProfilerStart(); #endif timer.reset(); - typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + typedef internal_vector_type scratch_value_type; + typedef Kokkos::View scratch_view_type; + const int per_team_scratch = scratch_view_type::shmem_size(4, Blk, AA.extent(5)); + using policy_type = Kokkos::TeamPolicy; - policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + using member_type = typename policy_type::member_type; + policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); for (int iter=0;iter default_mode_and_algo_type; - typedef default_mode_and_algo_type::mode_type mode_type; - typedef default_mode_and_algo_type::algo_type algo_type; - - const int i = member.league_rank(); - Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { - auto A = Kokkos::subview(AA, i, Kokkos::ALL(), 1, Kokkos::ALL(), Kokkos::ALL(), v); - auto B = Kokkos::subview(AA, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); - auto C = Kokkos::subview(AA, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); - - for (int jvec=0;jvec - ::invoke(member, bk, xb); - member.team_barrier(); - } - } - const int kend = L - 1; - for (int k=0;k - ::invoke(member, bk, xb); - } - - Trsv - ::invoke(member, 1.0, LT, xt); - - Gemv - ::invoke(member, -1.0, LB, xt, 1.0, xb); - } - { - LT.assign_data(&A(kend, 0, 0)); - xt.assign_data(&x(kend, 0)); - Trsv - ::invoke(member, 1.0, LT, xt); - } - } /// end forward substitution - - /// - /// backward substitution - /// - { - auto UT = Kokkos::subview(B, 0, Kokkos::ALL(), Kokkos::ALL()); - auto UB = Kokkos::subview(A, 0, Kokkos::ALL(), Kokkos::ALL()); - - const int kbegin = L - 1; - for (int k=kbegin;k>0;--k) { - UT.assign_data(&B(k-1, 0, 0)); - UB.assign_data(&A(k, 0, 0)); - - xt.assign_data(&x(k-1, 0, 0)); - xb.assign_data(&x(k, 0, 0)); - - Trsv - ::invoke(member, 1.0, UB, xb); - - Gemv - ::invoke(member, -1.0, UT, xb, 1.0, xt); - } - { - UB.assign_data(&A(0, 0, 0)); - xb.assign_data(&x(0, 0)); - Trsv - ::invoke(member, 1.0, UB, xb); - } - } // end backward substitution - } - }); - }); - Kokkos::fence(); + for (int nis=0;nis default_mode_and_algo_type; + typedef default_mode_and_algo_type::mode_type mode_type; + typedef default_mode_and_algo_type::algo_type algo_type; + + scratch_view_type WW(member.team_scratch(0), 4, Blk, AA.extent(5)); + + const int i = member.league_rank()/L; + const int k = member.league_rank()%L; + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { + auto A = Kokkos::subview(AA, i, k, 1, Kokkos::ALL(), Kokkos::ALL(), v); + auto D = Kokkos::subview(AA, i, k, 3, Kokkos::ALL(), Kokkos::ALL(), v); + auto B = Kokkos::subview(AA, i, k, 2, Kokkos::ALL(), Kokkos::ALL(), v); + auto C = Kokkos::subview(AA, i, k ? k-1 : 0, 0, Kokkos::ALL(), Kokkos::ALL(), v); + + auto w0 = Kokkos::subview(WW, 0, Kokkos::ALL(), v); + auto w1 = Kokkos::subview(WW, 1, Kokkos::ALL(), v); + auto w2 = Kokkos::subview(WW, 2, Kokkos::ALL(), v); + auto u = Kokkos::subview(WW, 3, Kokkos::ALL(), v); + + for (int jvec=0;jvec::invoke(member, 1.0, D, b, 0.0, x1); + } else { + Copy::invoke(member, b, u); + Copy::invoke(member, x1, w1); + Gemv::invoke(member, -1.0, A, w1, 1.0, u); + + if (k == 0) { + Copy::invoke(member, x2, w2); + Gemv::invoke(member, -1.0, B, w2, 1.0, u); + } else if (k == L-1) { + Copy::invoke(member, x0, w0); + Gemv::invoke(member, -1.0, C, w0, 1.0, u); + } else { + Copy::invoke(member, x0, w0); + Copy::invoke(member, x2, w2); + Gemv::invoke(member, -1.0, B, w2, 1.0, u); + Gemv::invoke(member, -1.0, C, w0, 1.0, u); + } + Gemv::invoke(member, 1.0, D, u, 1.0, x1); + } + } + }); + }); + Kokkos::fence(); + } } const double t = timer.seconds(); #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) @@ -439,7 +415,7 @@ int main(int argc, char* argv[]) { /// /// compute residual /// - if (0) { + if (1) { typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 2f1dc53916..33784bcb14 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -30,7 +30,7 @@ #include #include -//#define KOKKOSBATCHED_PROFILE 1 +#define KOKKOSBATCHED_PROFILE 1 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) #include "cuda_profiler_api.h" #endif From 86c3f41702afed10ed792cc1260ad660c56606da Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 21 Feb 2019 17:33:10 -0700 Subject: [PATCH 134/190] KokkosBatched - async jacobi cleaning --- ...osBatched_Test_BlockTridiagAsyncJacobi.cpp | 54 ++++--------------- 1 file changed, 11 insertions(+), 43 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp index 8aa19c8598..8ca9f1a4cc 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp @@ -169,26 +169,6 @@ int main(int argc, char* argv[]) { xv.extent(3), vector_length/internal_vector_length); - /// double 16 - Kokkos::View yv("y", - N/vector_length, Nvec, L, Blk); - - /// double - Kokkos::View ys((value_type*)yv.data(), - yv.extent(0), - yv.extent(1), - yv.extent(2), - yv.extent(3), - vector_length); - - /// double 2 - Kokkos::View yi((internal_vector_type*)yv.data(), - yv.extent(0), - yv.extent(1), - yv.extent(2), - yv.extent(3), - vector_length/internal_vector_length); - /// double 16 Kokkos::View bv("b", N/vector_length, Nvec, L, Blk); @@ -229,7 +209,6 @@ int main(int argc, char* argv[]) { auto AA = Ai; auto bb = bi; auto xx = xi; - auto yy = yi; // auto AA = As; // auto bb = bs; @@ -258,7 +237,7 @@ int main(int argc, char* argv[]) { const int k = member.league_rank()%L; Kokkos::parallel_for(Kokkos::TeamThreadRange(member,Blk),[&](const int &j) { Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { - AA(i, k, 1, j, j, v) += internal_vector_type(3*Blk); + AA(i, k, 1, j, j, v) += internal_vector_type(9*Blk); }); }); }); @@ -340,9 +319,9 @@ int main(int argc, char* argv[]) { #endif timer.reset(); typedef internal_vector_type scratch_value_type; - typedef Kokkos::View scratch_view_type; - const int per_team_scratch = scratch_view_type::shmem_size(4, Blk, AA.extent(5)); + const int per_team_scratch = scratch_view_type::shmem_size(Blk, AA.extent(5)); using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; @@ -357,7 +336,7 @@ int main(int argc, char* argv[]) { typedef default_mode_and_algo_type::mode_type mode_type; typedef default_mode_and_algo_type::algo_type algo_type; - scratch_view_type WW(member.team_scratch(0), 4, Blk, AA.extent(5)); + scratch_view_type WW(member.team_scratch(0), Blk, AA.extent(5)); const int i = member.league_rank()/L; const int k = member.league_rank()%L; @@ -367,11 +346,7 @@ int main(int argc, char* argv[]) { auto B = Kokkos::subview(AA, i, k, 2, Kokkos::ALL(), Kokkos::ALL(), v); auto C = Kokkos::subview(AA, i, k ? k-1 : 0, 0, Kokkos::ALL(), Kokkos::ALL(), v); - auto w0 = Kokkos::subview(WW, 0, Kokkos::ALL(), v); - auto w1 = Kokkos::subview(WW, 1, Kokkos::ALL(), v); - auto w2 = Kokkos::subview(WW, 2, Kokkos::ALL(), v); - auto u = Kokkos::subview(WW, 3, Kokkos::ALL(), v); - + auto u = Kokkos::subview(WW, Kokkos::ALL(), v); for (int jvec=0;jvec::invoke(member, 1.0, D, b, 0.0, x1); } else { Copy::invoke(member, b, u); - Copy::invoke(member, x1, w1); - Gemv::invoke(member, -1.0, A, w1, 1.0, u); - if (k == 0) { - Copy::invoke(member, x2, w2); - Gemv::invoke(member, -1.0, B, w2, 1.0, u); + Gemv::invoke(member, -1.0, B, x2, 1.0, u); } else if (k == L-1) { - Copy::invoke(member, x0, w0); - Gemv::invoke(member, -1.0, C, w0, 1.0, u); + Gemv::invoke(member, -1.0, C, x0, 1.0, u); } else { - Copy::invoke(member, x0, w0); - Copy::invoke(member, x2, w2); - Gemv::invoke(member, -1.0, B, w2, 1.0, u); - Gemv::invoke(member, -1.0, C, w0, 1.0, u); + Gemv::invoke(member, -1.0, B, x2, 1.0, u); + Gemv::invoke(member, -1.0, C, x0, 1.0, u); } - Gemv::invoke(member, 1.0, D, u, 1.0, x1); + Gemv::invoke(member, 1.0, D, u, 0.0, x1); } } }); }); - Kokkos::fence(); } + Kokkos::fence(); } const double t = timer.seconds(); #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOSBATCHED_PROFILE) From b970e8fe43d1f93d1d22a801442903d9eb335389 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 21 Feb 2019 17:45:06 -0700 Subject: [PATCH 135/190] KokkosBatched - async testing --- .../KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp index 8ca9f1a4cc..2660e37975 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp @@ -325,9 +325,9 @@ int main(int argc, char* argv[]) { using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); + policy_type policy(AA.extent(0)*L*nsweep, Kokkos::AUTO(), AA.extent(5)); for (int iter=0;iter Date: Fri, 22 Feb 2019 14:10:33 -0700 Subject: [PATCH 136/190] KokkosBatched - jacobi iteration --- ...KokkosBatched_Test_BlockTridiagJacobi.cpp} | 41 +++++++++++-------- 1 file changed, 24 insertions(+), 17 deletions(-) rename perf_test/batched/{KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp => KokkosBatched_Test_BlockTridiagJacobi.cpp} (92%) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp similarity index 92% rename from perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp rename to perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp index 2660e37975..4db40215fb 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagAsyncJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp @@ -150,23 +150,25 @@ int main(int argc, char* argv[]) { Av.extent(4), vector_length/internal_vector_length); /// double 16 - Kokkos::View xv("x", - N/vector_length, Nvec, L, Blk); + Kokkos::View xv("x", + N/vector_length, Nvec, 2, L, Blk); /// double - Kokkos::View xs((value_type*)xv.data(), + Kokkos::View xs((value_type*)xv.data(), xv.extent(0), xv.extent(1), xv.extent(2), xv.extent(3), + xv.extent(4), vector_length); /// double 2 - Kokkos::View xi((internal_vector_type*)xv.data(), + Kokkos::View xi((internal_vector_type*)xv.data(), xv.extent(0), xv.extent(1), xv.extent(2), xv.extent(3), + xv.extent(4), vector_length/internal_vector_length); /// double 16 @@ -325,9 +327,13 @@ int main(int argc, char* argv[]) { using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0)*L*nsweep, Kokkos::AUTO(), AA.extent(5)); + policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); + for (int iter=0;iter::invoke(member, 1.0, D, b, 0.0, x1); @@ -364,11 +370,12 @@ int main(int argc, char* argv[]) { Gemv::invoke(member, -1.0, B, x2, 1.0, u); Gemv::invoke(member, -1.0, C, x0, 1.0, u); } - Gemv::invoke(member, 1.0, D, u, 0.0, x1); + Gemv::invoke(member, 1.0, D, u, 0.0, y1); } } }); }); + auto tmp = xxx; xxx = yyy; yyy = tmp; } Kokkos::fence(); } @@ -396,9 +403,9 @@ int main(int argc, char* argv[]) { auto C = Kokkos::subview(Acopy, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); for (int jvec=0;jvec Date: Sat, 23 Feb 2019 23:49:32 -0700 Subject: [PATCH 137/190] KokkosBatched - residual compute --- perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 33784bcb14..170e47486c 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -454,7 +454,7 @@ int main(int argc, char* argv[]) { /// /// compute residual /// - if (0) { + if (1) { typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; From 4ffd63269186369cf657ba61ec8d7f3276b06593 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Tue, 26 Feb 2019 13:15:41 -0700 Subject: [PATCH 138/190] D2GC: Cleanup some comments --- src/graph/KokkosGraph_Distance2Color.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/graph/KokkosGraph_Distance2Color.hpp b/src/graph/KokkosGraph_Distance2Color.hpp index fdb952e83d..971c98c522 100644 --- a/src/graph/KokkosGraph_Distance2Color.hpp +++ b/src/graph/KokkosGraph_Distance2Color.hpp @@ -45,7 +45,7 @@ #include "KokkosGraph_Distance1ColorHandle.hpp" #include "KokkosGraph_Distance2ColorHandle.hpp" -#include "KokkosGraph_Distance1Color_impl.hpp" // TODO: can I remove the D2 SERIAL entirely from this? (WCMCLEN-SCAFFOLDING) +#include "KokkosGraph_Distance1Color_impl.hpp" #include "KokkosGraph_Distance2Color_impl.hpp" #include "KokkosGraph_Distance2Color_MatrixSquared_impl.hpp" From c4f9b22c993f483a8bc9ac7414b85c0f11547d57 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 27 Feb 2019 09:12:22 -0700 Subject: [PATCH 139/190] KokkosBatched - For Si --- .../KokkosBatched_Test_BlockTridiagDirect.cpp | 17 ++++++++--------- .../KokkosBatched_Test_BlockTridiagJacobi.cpp | 14 +++++++------- src/batched/KokkosBatched_Vector_SIMD_Misc.hpp | 6 ++++-- 3 files changed, 19 insertions(+), 18 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 170e47486c..809704ad0c 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -95,7 +95,7 @@ int main(int argc, char* argv[]) { #endif Kokkos::print_configuration(std::cout); - typedef Kokkos::Details::ArithTraits ats; + //typedef Kokkos::Details::ArithTraits ats; Kokkos::Impl::Timer timer; /// @@ -227,7 +227,7 @@ int main(int argc, char* argv[]) { const int i = member.league_rank(); Kokkos::parallel_for(Kokkos::TeamThreadRange(member,AA.extent(1)),[&](const int &j) { Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, AA.extent(5)),[&](const int &v) { - for (int k=0;k; using member_type = typename policy_type::member_type; policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); @@ -468,7 +467,7 @@ int main(int argc, char* argv[]) { auto B = Kokkos::subview(Acopy, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); auto C = Kokkos::subview(Acopy, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); - for (int jvec=0;jvec ats; + //typedef Kokkos::Details::ArithTraits ats; Kokkos::Impl::Timer timer; /// @@ -402,7 +402,7 @@ int main(int argc, char* argv[]) { auto B = Kokkos::subview(Acopy, i, Kokkos::ALL(), 2, Kokkos::ALL(), Kokkos::ALL(), v); auto C = Kokkos::subview(Acopy, i, Kokkos::ALL(), 0, Kokkos::ALL(), Kokkos::ALL(), v); - for (int jvec=0;jvec,l> &val) { return reduce(val, [](const T left, const T right) -> T { - return min(left,right); + const auto tmp = left < right; + return tmp*left + !tmp*right; }); } @@ -174,7 +175,8 @@ namespace KokkosBatched { T max(const Vector,l> &val) { return reduce(val, [](const T left, const T right) -> T { - return max(left,right); + const auto tmp = left > right; + return tmp*left + !tmp*right; }); } From 1530be57c2402626404d59fb01ecb8d30294dc54 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 27 Feb 2019 10:55:19 -0700 Subject: [PATCH 140/190] D2GC: Fixing 'declaration hides member' error --- .../impl/KokkosGraph_Distance2Color_impl.hpp | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index 00cecaef12..aa3c7930ba 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -1163,19 +1163,19 @@ class GraphColorDistance2 nnz_lno_temp_work_view_t _vertexList; // nnz_lno_type _vertexListLength; // - functorGreedyColorVB_BIT_EF(nnz_lno_type nv, - const_lno_row_view_type xadj, - nnz_lno_temp_work_view_t adj, - const_clno_row_view_t t_xadj, - non_const_clno_nnz_view_t t_adj, + functorGreedyColorVB_BIT_EF(nnz_lno_type nv_, + const_lno_row_view_type xadj_, + nnz_lno_temp_work_view_t adj_, + const_clno_row_view_t t_xadj_, + non_const_clno_nnz_view_t t_adj_, color_view_type colors, nnz_lno_temp_work_view_t vertexList, nnz_lno_type vertexListLength) - : _nv(nv) - , _idx(xadj) - , _adj(adj) - , _t_idx(t_xadj) - , _t_adj(t_adj) + : _nv(nv_) + , _idx(xadj_) + , _adj(adj_) + , _t_idx(t_xadj_) + , _t_adj(t_adj_) , _colors(colors) , _vertexList(vertexList) , _vertexListLength(vertexListLength) From f8c9736ccfac6c6daf889e7c3e1c43b31904c21e Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 6 Mar 2019 10:34:39 -0700 Subject: [PATCH 141/190] Add doc/kokkos-promotion.txt file Documentation for promotion testing process --- doc/kokkos-promotion.txt | 240 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 240 insertions(+) create mode 100644 doc/kokkos-promotion.txt diff --git a/doc/kokkos-promotion.txt b/doc/kokkos-promotion.txt new file mode 100644 index 0000000000..b1330e8a70 --- /dev/null +++ b/doc/kokkos-promotion.txt @@ -0,0 +1,240 @@ +Summary: + +- Step 1: Testing Kokkos + KokkosKernels using test_all_sandia + +- Step 2: Testing of Kokkos + KokkosKernels integrated into Trilinos (scripts/trilinos-integration/*.sh) + +- Step 3: Close all issues labeled "InDevelop" + +- Step 4: Locally update CHANGELOG, merge into master, edit scripts/master_history.txt + +- Step 5: Locally snapshot new master of kokkos and kokkos-kernels into corresponding Trilinos branch (develop or temporary), issue PR to Trilinos + +- Step 6: Push local Kokkos master to GitHub (need Owner approval). Push local KokkosKernels master to GitHub (need Owner approval) + +Steps 1, 2, and 4 include testing that may fail. These failures must be fixed either by pull requests to Kokkos and/or KokkosKernels develop, or by creating a new Trilinos branch for parts of Trilinos that must be updated. This is what usually takes the most time. + + +// -------------------------------------------------------------------------------- // + + +Step 1: The following should be repeated on enough machines to cover all +supported compilers. Those machines are: + + kokkos-dev + blake + white + bowman + waterman + + 1.1. Clone kokkos develop branch (or just switch to it) + + git clone -b develop git@github.com:kokkos/kokkos.git + cd kokkos + + 1.2. Create a testing directory + + mkdir testing + cd testing + + 1.3. Run the test_all_sandia script with no options to test all compilers + + nohup ../scripts/test_all_sandia & + tail -f nohup.out # to watch progress + + 1.4. Clone kokkos-kernels develop branch (or just switch to it) + + git clone -b develop git@github.com:kokkos/kokkos-kernels.git + cd kokkos-kernels + + 1.4. Create a testing directory + + mkdir testing + cd testing + + 1.5. Run the test_all_sandia script with no options to test all compilers + + nohup ../scripts/test_all_sandia & + tail -f nohup.out # to watch progress + +// -------------------------------------------------------------------------------- // + +Step 2: + 2.1. Build and test Trilinos with 4 different configurations; Run scripts for white and blake that are provided in kokkos-kernels/scripts/trilinos-integration. These scripts load their own modules/environment, so don't require preparation. You can run all four at the same time, use separate directories for each. + + mkdir serial + cd serial + nohup KOKKOSKERNELS_PATH/scripts/trilinos-integration/blake_jenkins_run_script_serial_intel & + + 2.2. Compare the compile errors and test failures between updated and pristine versions. There may be compile failures that happen in both, tests that fail in both, and there may be tests that only fail some times (thus, rerun tests manually as needed). + +// -------------------------------------------------------------------------------- // + +Step 3: Close all issues labeled "InDevelop" + + Use the GitHub web interface: https://github.com/kokkos/kokkos/issues?q=is%3Aopen+is%3Aissue+label%3AInDevelop + Select all with checkbox in upper left, "Mark as closed" + + Use the GitHub web interface: https://github.com/kokkos/kokkos-kernels/issues?q=is%3Aopen+is%3Aissue+label%3AInDevelop + Select all with checkbox in upper left, "Mark as closed" + +// -------------------------------------------------------------------------------- // + +Step 4: This step should be run on kokkos-dev + + 4.1. If you don't have a GitHub token already, generate one for yourself (this will give you TOKEN): + + https://github.com/settings/tokens + + 4.2. Get a clean copy of the kokkos and kokkos-kernels develop branches + + git clone -b develop git@github.com:kokkos/kokkos.git + git clone -b develop git@github.com:kokkos/kokkos-kernels.git + + 4.3. If you haven't already, install Ruby and the "github_changelog_generator" "gem" + The github_changelog_generator is here: https://github.com/skywinder/github-changelog-generator + Its compatible Ruby version can be found here: https://github.com/skywinder/github-changelog-generator/blob/master/.ruby-version + Grab the corresponding Ruby version from here: https://www.ruby-lang.org/en/downloads/ + Follow the usual configure,make,make install process: https://www.ruby-lang.org/en/documentation/installation/#building-from-source + Note that you will likely have to install to a non-default location with "./configure --prefix=/path" + + 4.4. Generate the initial changelog. Use the most recent tag as OLDTAG (`git tag -l` can show you all tags). The NEWTAG is the new version number, e.g. "2.04.00". + RUN THIS OUTSIDE THE KOKKOS SOURCE TREE! + + NOTE: You likely need to set an HTTPS proxy in order for this script to work: + + export https_proxy=http://wwwproxy.sandia.gov:80 + + github_changelog_generator kokkos/kokkos --token TOKEN --no-pull-requests --include-labels 'InDevelop' --exclude-labels 'question,DevelopOnly' --enhancement-labels 'enhancement,Feature Request' --future-release 'NEWTAG' --between-tags 'NEWTAG,OLDTAG' + + github_changelog_generator kokkos/kokkos-kernels --token TOKEN --no-pull-requests --include-labels 'InDevelop' --exclude-labels 'question,DevelopOnly' --enhancement-labels 'enhancement,Feature Request' --future-release 'NEWTAG' --between-tags 'NEWTAG,OLDTAG' + + 4.5. Manually cleanup and commit the change log. + (Copy the new section from the generated CHANGELOG.md to the corresponding KOKKOS_PATH/CHANGELOG.md or KOKKOSKERNELS_PATH/CHANGELOG.md) + (Make desired changes to CHANGELOG.md to enhance clarity (remove issues not noteworthy)) + (Commit the CHANGELOG.md locally to develop) + + The changelog commit message should be: + + Adding Changelog for Release A.B.CD + + Part of Kokkos C++ Performance Portability Programming EcoSystem A.B + + 4.6. Merge develop into master. DO NOT FAST-FORWARD THE MERGE!!!! + DO NOT USE AN OLD GIT VERSION!!!! + + (From kokkos directory): + git checkout master + git merge --no-ff develop + + The merge commit message should be: + + Merge branch 'develop' for A.B.CD + + Part of Kokkos C++ Performance Portability Programming EcoSystem A.B + + (From kokkos-kernels directory): + git checkout master + git merge --no-ff develop + + The merge commit message should be: + + Merge branch 'develop' for A.B.CD + + Part of Kokkos C++ Performance Portability Programming EcoSystem A.B + + 4.7. Update the tag in kokkos/master_history.txt, then update the tag in kokkos-kernels/master_history.txt + + Tag description: MajorNumber.MinorNumber.WeeksSinceMinorNumberUpdate + Tag field widths: #.#.## + date description: month:day:year + date field widths: ##:##:#### + master description: SHA1 of previous master commit (use `git log --first-parent master`) + develop description: SHA1 of merged develop branch (use `git log develop`) + SHA1 field width: ######## (8 chars) + + # Append to scripts/master_history.txt: + + tag: 2.03.13 date: 07:27:2017 master: da314444 develop: 29ccb58a + + git commit --amend -a + + Keep the merge commit as described in 4.6 + + 4.8. Create the new tag (repeat for kokkos and kokkos-kernels): + + git tag -a #.#.## + + (type the following into the tag message (same as for step 4.7)) + tag: #.#.## + date: mm/dd/yyyy + master: sha1 + develop: sha1 + + 4.9. DO NOT PUSH YET !!! + + +// -------------------------------------------------------------------------------- // + +Step 5: This step can be done on any SEMS machine (e.g. kokkos-dev). + + 5.1. Clone the Trilinos corresponding branch (or just switch to it) + + git clone -b kokkos-promotion git@github.com:trilinos/Trilinos.git + TRILINOS_PATH=$PWD/Trilinos + + 5.2. Snapshot Kokkos into Trilinos - this requires python/2.7.9 and that both Trilinos and Kokkos be clean - no untracked or modified files. Run the following outside of the Kokkos and Trilinos source trees. + + * Use the master branch of Kokkos for this. + + module load sems-python/2.7.9 + python $KOKKOS_PATH/scripts/snapshot.py $KOKKOS_PATH $TRILINOS_PATH/packages + python $KOKKOS_PATH/scripts/snapshot.py $KOKKOSKERNELS_PATH $TRILINOS_PATH/packages + + If snapshotting kokkos-kernels, use the snapshot.py in kokkos. + + 5.3. Push this Trilinos branch to GitHub, open a pull request for it. + The pull request title should be: + + Kokkos + KokkosKernels Promotion To X.X.XX + + In the message body, mention @trilinos/kokkos and @trilinos/kokkos-kernels, + + Add a short description of the most significant features and bug fixes, + + Then add: + + ## Kokkos Changelog + + And copy-paste the content for this release from the kokkos CHANGELOG.md file, then do the same for kokkos-kernels under: + + ## KokkosKernels Changelog + + 5.4. Wait for Trilinos Autotester results + + 5.5. If there are failures, fix and backtrack. Otherwise, merge into Trilinos' develop branch and go to next step + +// -------------------------------------------------------------------------------- // + +Step 6: Push Kokkos + KokkosKernels master and develop branches to respective GitHub repos (requires Owner permission). + + 6.1. Master branch: + cd KOKKOS_PATH + git checkout master + git push --follow-tags origin master + + cd KOKKOSKERNELS_PATH + git checkout master + git push --follow-tags origin master + + 6.2. Develop branch: First merge (--no-ff) master back into develop + cd KOKKOS_PATH + git checkout develop + git merge --no-ff master + git push origin develop + + cd KOKKOSKERNELS_PATH + git checkout develop + git merge --no-ff master + git push origin develop + From a5acc27dd312d5c49e7f6e7811de6554a770f163 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 6 Mar 2019 11:46:27 -0700 Subject: [PATCH 142/190] Update test_all_sandia 1. Recognize kokkos-dev machine 2. Update sems-recongnized machines: modules tested are common to both rhel6 and rhel7 envs remove use of kokkos-env modules --- scripts/test_all_sandia | 53 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 3 deletions(-) diff --git a/scripts/test_all_sandia b/scripts/test_all_sandia index d9eca20f4f..f1d170c274 100755 --- a/scripts/test_all_sandia +++ b/scripts/test_all_sandia @@ -35,10 +35,16 @@ if [[ "$HOSTNAME" == mayer\.* ]]; then MACHINE=mayer # module load git fi + if [[ "$HOSTNAME" == cn* ]]; then # Warning: very generic name MACHINE=mayer fi +if [[ "$HOSTNAME" == kokkos-dev\.sandia\.gov* ]]; then + MACHINE=kokkos-dev + echo $MACHINE +fi + if [ ! -z "$SEMS_MODULEFILES_ROOT" ]; then if [[ "$MACHINE" = "" ]]; then MACHINE=sems @@ -201,6 +207,47 @@ fi if [ "$MACHINE" = "sems" ]; then source /projects/sems/modulefiles/utils/sems-modules-init.sh + # On unnamed sems machines, assume more restricted rhel7 environment + # On rhel7 sems machines gcc/7.3.0 and clang/4.0.1 are missing + # Remove kokkkos-env module use + + BASE_MODULE_LIST="sems-env,sems-/" + CUDA9_MODULE_LIST="sems-env,sems-/,sems-gcc/7.2.0" + SKIP_HWLOC=True + # No sems hwloc module + + if [ -z "$ARCH_FLAG" ]; then + ARCH_FLAG="" + fi + + if [ "$SPOT_CHECK" = "True" ]; then + # Format: (compiler module-list build-list exe-name warning-flag) + COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST "OpenMP" g++ $GCC_WARNING_FLAGS" + "gcc/7.2.0 $BASE_MODULE_LIST "Serial" g++ $GCC_WARNING_FLAGS" + "intel/17.0.1 $BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS" + "clang/3.9.0 $BASE_MODULE_LIST "Pthread_Serial" clang++ $CLANG_WARNING_FLAGS" + "cuda/9.2 $CUDA9_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" + ) + else + # Format: (compiler module-list build-list exe-name warning-flag) + COMPILERS=("gcc/4.8.4 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" + "gcc/4.9.3 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" + "gcc/5.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" + "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" + "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" + "intel/15.0.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" + "intel/16.0.3 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" + "intel/17.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" + "clang/3.6.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" + "clang/3.7.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" + "clang/3.8.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" + "clang/3.9.0 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" + "cuda/9.2 $CUDA9_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" + ) + fi +elif [ "$MACHINE" = "kokkos-dev" ]; then + source /projects/sems/modulefiles/utils/sems-modules-init.sh + BASE_MODULE_LIST="sems-env,kokkos-env,kokkos-hwloc/1.10.1/base,sems-/" CUDA_MODULE_LIST="sems-env,kokkos-env,kokkos-/,sems-gcc/4.8.4,kokkos-hwloc/1.10.1/base" CUDA8_MODULE_LIST="sems-env,kokkos-env,kokkos-/,sems-gcc/5.3.0,kokkos-hwloc/1.10.1/base" @@ -358,9 +405,9 @@ elif [ "$MACHINE" = "apollo" ]; then BASE_MODULE_LIST="sems-env,kokkos-env,kokkos-hwloc/1.10.1/base,sems-/" CUDA_MODULE_LIST="sems-env,kokkos-env,kokkos-/,sems-gcc/5.3.0,kokkos-hwloc/1.10.1/base" - CLANG_MODULE_LIST="sems-env,kokkos-env,sems-git,sems-cmake/3.5.2,/,cuda/9.0.69" - CLANG7_MODULE_LIST="sems-env,kokkos-env,sems-git,sems-cmake/3.5.2,/,cuda/9.1" - NVCC_MODULE_LIST="sems-env,kokkos-env,sems-git,sems-cmake/3.5.2,/,sems-gcc/5.3.0" + CLANG_MODULE_LIST="sems-env,kokkos-env,/,cuda/9.0.69" + CLANG7_MODULE_LIST="sems-env,kokkos-env,/,cuda/9.1" + NVCC_MODULE_LIST="sems-env,kokkos-env,/,sems-gcc/5.3.0" BUILD_LIST_CUDA_NVCC="Cuda_Serial,Cuda_OpenMP" BUILD_LIST_CUDA_CLANG="Cuda_Serial,Cuda_Pthread" From 71915e56f711b548d736dfc52a61d8795db4ea6f Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 6 Mar 2019 11:56:50 -0700 Subject: [PATCH 143/190] test_all_sandia: add note for killing test_all_sandia jobs --- doc/kokkos-promotion.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/kokkos-promotion.txt b/doc/kokkos-promotion.txt index b1330e8a70..9366ee6b33 100644 --- a/doc/kokkos-promotion.txt +++ b/doc/kokkos-promotion.txt @@ -42,6 +42,11 @@ supported compilers. Those machines are: nohup ../scripts/test_all_sandia & tail -f nohup.out # to watch progress + NOTE: To kill jobs not running in the background (hopefully prevent ghost processes): + + control+z + kill -9 %1 + 1.4. Clone kokkos-kernels develop branch (or just switch to it) git clone -b develop git@github.com:kokkos/kokkos-kernels.git @@ -57,6 +62,11 @@ supported compilers. Those machines are: nohup ../scripts/test_all_sandia & tail -f nohup.out # to watch progress + NOTE: To kill jobs not running in the background (hopefully prevent ghost processes): + + control+z + kill -9 %1 + // -------------------------------------------------------------------------------- // Step 2: From 2e0c385c3285905f49e039fb9fb94741da6f6f30 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 6 Mar 2019 14:13:39 -0700 Subject: [PATCH 144/190] test_all_sandia: update intel compiler for sems env intel/16.0.3 is not available on rhel6 sems env; use 16.0.1 --- scripts/test_all_sandia | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/test_all_sandia b/scripts/test_all_sandia index f1d170c274..6d3da56efd 100755 --- a/scripts/test_all_sandia +++ b/scripts/test_all_sandia @@ -208,7 +208,7 @@ if [ "$MACHINE" = "sems" ]; then source /projects/sems/modulefiles/utils/sems-modules-init.sh # On unnamed sems machines, assume more restricted rhel7 environment - # On rhel7 sems machines gcc/7.3.0 and clang/4.0.1 are missing + # On rhel7 sems machines gcc/7.3.0, clang/4.0.1, and intel/16.0.3 are missing # Remove kokkkos-env module use BASE_MODULE_LIST="sems-env,sems-/" @@ -236,7 +236,7 @@ if [ "$MACHINE" = "sems" ]; then "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS" "intel/15.0.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" - "intel/16.0.3 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" + "intel/16.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" "intel/17.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS" "clang/3.6.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" "clang/3.7.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS" From ea15f6db6fbc85eec03235ed237d9e80a1400533 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Wed, 6 Mar 2019 15:11:03 -0700 Subject: [PATCH 145/190] KokkosBatched - pointer based copy operations --- src/batched/KokkosBatched_Copy_Decl.hpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/batched/KokkosBatched_Copy_Decl.hpp b/src/batched/KokkosBatched_Copy_Decl.hpp index 6ce56cba65..f379e7756e 100644 --- a/src/batched/KokkosBatched_Copy_Decl.hpp +++ b/src/batched/KokkosBatched_Copy_Decl.hpp @@ -68,4 +68,27 @@ namespace KokkosBatched { } +#define KOKKOSBATCHED_SERIAL_COPY_MATRIX_NO_TRANSPOSE_INTERNAL_INVOKE(M,N,A,AS0,AS1,B,BS0,BS1) \ + KokkosBatched::Experimental::SerialCopyInternal \ + ::invoke(M, N, A, AS0, AS1, B, BS0, BS1) + +#define KOKKOSBATCHED_TEAM_COPY_MATRIX_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,N,A,AS0,AS1,B,BS0,BS1) \ + KokkosBatched::Experimental::TeamCopyInternal \ + ::invoke(MEMBER, M, N, A, AS0, AS1, B, BS0, BS1) + +#define KOKKOSBATCHED_SERIAL_COPY_VECTOR_INTERNAL_INVOKE(M,A,AS,B,BS) \ + KokkosBatched::Experimental::SerialCopyInternal \ + ::invoke(M, A, AS, B, BS) + +#define KOKKOSBATCHED_TEAM_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,A,AS,B,BS) \ + KokkosBatched::Experimental::TeamCopyInternal \ + ::invoke(MEMBER, M, A, AS, B, BS) + +#define KOKKOSBATCHED_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,MEMBER,M,A,AS,B,BS) \ + if (std::is_same::value) { \ + KOKKOSBATCHED_SERIAL_COPY_VECTOR_INTERNAL_INVOKE(M,A,AS,B,BS); \ + } else if (std::is_same::value) { \ + KOKKOSBATCHED_TEAM_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,A,AS,B,BS); \ + } + #endif From 0a5dbc33cd6725f9f1d3042b049d49e607638f79 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 11 Mar 2019 11:52:09 -0600 Subject: [PATCH 146/190] KokkosBatched - for Si, put a macro for testing 64bit. --- .../KokkosBatched_Test_BlockTridiagDirect.cpp | 37 +++++++++++++++---- .../KokkosBatched_Test_BlockTridiagJacobi.cpp | 37 +++++++++++++++---- 2 files changed, 59 insertions(+), 15 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 809704ad0c..0fca187205 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -35,6 +35,8 @@ #include "cuda_profiler_api.h" #endif +//#define KOKKOSBATCHED_USE_128BIT_MEMORY_INST + typedef Kokkos::DefaultExecutionSpace exec_space; typedef typename exec_space::memory_space memory_space; typedef Kokkos::DefaultHostExecutionSpace host_space; @@ -48,10 +50,18 @@ typedef double value_type; using namespace KokkosBatched::Experimental; static constexpr int vector_length = DefaultVectorLength::value; +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) static constexpr int internal_vector_length = DefaultInternalVectorLength::value; +#else +static constexpr int internal_vector_length = 1; +#endif typedef Vector,vector_length> vector_type; +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) typedef Vector,internal_vector_length> internal_vector_type; +#else +typedef value_type internal_vector_type; +#endif template struct FactorizeModeAndAlgo; @@ -117,7 +127,8 @@ int main(int argc, char* argv[]) { if (token == std::string("-Niter")) niter = std::atoi(argv[++i]); } - printf(" :::: Testing (N = %d, L = %d, Blk = %d, vl = %d, vi = %d)\n", N, L, Blk, vector_length, internal_vector_length); + printf(" :::: Testing (N = %d, L = %d, Blk = %d, vl = %d, vi = %d, niter = %d)\n", + N, L, Blk, vector_length, internal_vector_length, niter); /// @@ -202,13 +213,15 @@ int main(int argc, char* argv[]) { bs.extent(3), bs.extent(4)); +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) auto AA = Ai; auto bb = bi; auto xx = xi; - - // auto AA = As; - // auto bb = bs; - // auto xx = xs; +#else + auto AA = As; + auto bb = bs; + auto xx = xs; +#endif /// /// set identity @@ -257,7 +270,12 @@ int main(int argc, char* argv[]) { timer.reset(); using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + int team_size = 0; + if (Blk < 8) { team_size = 32/AA.extent(5); + } else if (Blk < 12) { team_size = 64/AA.extent(5); + } else { team_size = 128/AA.extent(5); } + + policy_type policy(AA.extent(0), team_size, AA.extent(5)); Kokkos::parallel_for ("factorize", policy.set_scratch_size(0,Kokkos::PerTeam(S)), @@ -328,7 +346,12 @@ int main(int argc, char* argv[]) { timer.reset(); using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0), Kokkos::AUTO(), AA.extent(5)); + int team_size = 0; + if (Blk < 8) { team_size = 32/AA.extent(5); + } else if (Blk < 12) { team_size = 64/AA.extent(5); + } else { team_size = 128/AA.extent(5); } + + policy_type policy(AA.extent(0), team_size, AA.extent(5)); for (int iter=0;iter::value; +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) static constexpr int internal_vector_length = DefaultInternalVectorLength::value; +#else +static constexpr int internal_vector_length = 1; +#endif typedef Vector,vector_length> vector_type; +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) typedef Vector,internal_vector_length> internal_vector_type; +#else +typedef value_type internal_vector_type; +#endif template struct InverseDiagonalsModeAndAlgo; @@ -121,7 +131,8 @@ int main(int argc, char* argv[]) { if (token == std::string("-Nsweep")) nsweep = std::atoi(argv[++i]); } - printf(" :::: Testing (N = %d, L = %d, Blk = %d, vl = %d, vi = %d)\n", N, L, Blk, vector_length, internal_vector_length); + printf(" :::: Testing (N = %d, L = %d, Blk = %d, vl = %d, vi = %d, niter = %d, nsweep = %d)\n", + N, L, Blk, vector_length, internal_vector_length, niter, nsweep); /// @@ -208,14 +219,15 @@ int main(int argc, char* argv[]) { bs.extent(3), bs.extent(4)); +#if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) auto AA = Ai; auto bb = bi; auto xx = xi; - - // auto AA = As; - // auto bb = bs; - // auto xx = xs; - +#else + auto AA = As; + auto bb = bs; + auto xx = xs; +#endif /// randomize input Kokkos::Random_XorShift64_Pool random(13245); @@ -266,7 +278,12 @@ int main(int argc, char* argv[]) { using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; const int per_team_scratch = scratch_view_type::shmem_size(Blk, Blk, AA.extent(5)); - policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); + int team_size = 0; + if (Blk < 8) { team_size = 32/AA.extent(5); + } else if (Blk < 12) { team_size = 32/AA.extent(5); + } else { team_size = 64/AA.extent(5); } + + policy_type policy(AA.extent(0)*L, team_size, AA.extent(5)); Kokkos::parallel_for ("inverse diagonals", policy.set_scratch_size(0,Kokkos::PerTeam(S < per_team_scratch ? per_team_scratch : S)), @@ -327,7 +344,11 @@ int main(int argc, char* argv[]) { using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; - policy_type policy(AA.extent(0)*L, Kokkos::AUTO(), AA.extent(5)); + int team_size = 0; + if (Blk < 8) { team_size = 32/AA.extent(5); + } else if (Blk < 12) { team_size = 32/AA.extent(5); + } else { team_size = 32/AA.extent(5); } + policy_type policy(AA.extent(0)*L, team_size, AA.extent(5)); for (int iter=0;iter Date: Mon, 11 Mar 2019 12:03:26 -0600 Subject: [PATCH 147/190] KokkosBatched - default is 128bit --- perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 0fca187205..fedb357123 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -35,7 +35,7 @@ #include "cuda_profiler_api.h" #endif -//#define KOKKOSBATCHED_USE_128BIT_MEMORY_INST +#define KOKKOSBATCHED_USE_128BIT_MEMORY_INST typedef Kokkos::DefaultExecutionSpace exec_space; typedef typename exec_space::memory_space memory_space; From 3f234fb3699b83926de1a72ef4e9939bccdddd6b Mon Sep 17 00:00:00 2001 From: Mark Hoemmen Date: Fri, 15 Mar 2019 14:51:25 -0600 Subject: [PATCH 148/190] Fix #397 (Add GEMM CudaUVMSpace specializations) Add CudaUVMSpace specializations for GEMM. This should fix performance issues that @vbrunini noticed on CUDA. Thanks to @kyungjoo-kim and @vbrunini for feedback. Corresponding Trilinos patch: https://github.com/trilinos/Trilinos/pull/4649 --- .../tpls/KokkosBlas3_gemm_tpl_spec_avail.hpp | 8 ++++++++ .../tpls/KokkosBlas3_gemm_tpl_spec_decl.hpp | 20 +++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_avail.hpp b/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_avail.hpp index 15f6bbc9eb..86763a779b 100644 --- a/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_avail.hpp +++ b/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_avail.hpp @@ -119,35 +119,43 @@ struct gemm_tpl_spec_avail< \ #if defined (KOKKOSKERNELS_INST_DOUBLE) \ && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_FLOAT) \ && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_DOUBLE) \ && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_FLOAT) \ && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace) #endif #if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) + KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace) #endif #endif diff --git a/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_decl.hpp index d04a519535..d75223e6b4 100644 --- a/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_decl.hpp +++ b/src/impl/tpls/KokkosBlas3_gemm_tpl_spec_decl.hpp @@ -592,21 +592,41 @@ KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::Layout KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, true) KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, false) +KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, false) +KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_DGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, false) + KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, true) KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, false) KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, true) KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, false) +KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, false) +KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_SGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, false) + KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, true) KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, false) KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, true) KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, false) +KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, false) +KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_ZGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, false) + KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, true) KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaSpace, false) KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, true) KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace, false) +KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::LayoutLeft, Kokkos::CudaUVMSpace, false) +KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, true) +KOKKOSBLAS3_CGEMM_CUBLAS( Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaUVMSpace, false) + } } #endif // KOKKOSKERNELS_ENABLE_TPL_CUBLAS From ea56844e0ce607c6f931bbe1c8b0e3252ae6dc20 Mon Sep 17 00:00:00 2001 From: Siva Rajamanickam Date: Tue, 26 Mar 2019 12:28:08 -0600 Subject: [PATCH 149/190] Fix #401. IBM xlc related issue where we need to typecast the constant input to Kokkos atomc_fetch_add --- src/graph/impl/KokkosGraph_Distance1Color_impl.hpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp index a2e14423cc..ae994c6634 100644 --- a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp @@ -2626,6 +2626,7 @@ class GraphColor_VBD:public GraphColor ::type atomic_incr_type; int myScore = score_(node); int numNeighs = xadj_(node + 1) - xadj_(node); for(int neigh = 0; neigh < numNeighs; ++neigh) { @@ -2639,7 +2640,7 @@ class GraphColor_VBD:public GraphColor ::type atomic_incr_type; size_type frontierNode = frontier_(frontierIdx); int* bannedColors = new int[maxColors_]; for(size_type colorIdx= 0; colorIdx < maxColors_; ++colorIdx) { @@ -2690,7 +2692,7 @@ class GraphColor_VBD:public GraphColor ::type atomic_incr_type; size_type frontierNode = frontier_(frontierIdx); // Initialize bit array to all bits = 0 unsigned long long bannedColors = 0; @@ -2757,7 +2760,7 @@ class GraphColor_VBD:public GraphColor Date: Wed, 27 Mar 2019 15:19:44 -0600 Subject: [PATCH 150/190] Add --help to distance-1 graph coloring example --- perf_test/graph/KokkosGraph_color.cpp | 48 ++++++++++++++++++++++++--- 1 file changed, 44 insertions(+), 4 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index ada0009ebe..891f915c0a 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -57,10 +57,46 @@ -void print_options(){ - +void print_options(std::ostream &os, const char *app_name, unsigned int indent = 0) +{ + std::string spaces(indent, ' '); + os << "Usage:" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl + << std::endl + << spaces << "Parameters:" << std::endl + << spaces << " Parallelism (select one of the following):" << std::endl + << spaces << " --serial Execute serially." << std::endl + << spaces << " --threads Use N posix threads." << std::endl + << spaces << " --openmp Use OpenMP with N threads." << std::endl + << spaces << " --cuda Use CUDA" << std::endl + << std::endl + << spaces << " Required Parameters:" << std::endl + << spaces << " --amtx Input file in Matrix Market format (.mtx)." << std::endl + << std::endl + << spaces << " --algorithm Set the algorithm to use. Allowable values are:" << std::endl + << spaces << " COLORING_DEFAULT - Use the default coloring method, architecture dependent." << std::endl + << spaces << " COLORING_SERIAL - Use the serial algorithm." << std::endl + << spaces << " COLORING_VB - Use the parallel vertex-based method." << std::endl + << spaces << " COLORING_VBBIT - Use the parallel vertex-based with bit vectors method." << std::endl + << spaces << " COLORING_EB - Use edge based method." << std::endl + << spaces << " COLORING_VBD - Use the vertex-based deterministic method." << std::endl + << spaces << " COLORING_VBDBIT - Use the vertex-based deterministic with bit vectors method." << std::endl + << std::endl + << spaces << " Optional Parameters:" << std::endl + << spaces << " --repeat Set number of test repetitions (Default: 1) " << std::endl + << spaces << " --verbose Enable verbose mode (record and print timing + extra information)" << std::endl + << spaces << " --chunksize Set the chunk size." << std::endl + << spaces << " --dynamic Use dynamic scheduling." << std::endl + << spaces << " --teamsize Set the team size." << std::endl + << spaces << " --vectorsize Set the vector size." << std::endl + << spaces << " --help Print out command line help." << std::endl + << spaces << " " << std::endl; } -int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv){ + + + +int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) +{ for ( int i = 1 ; i < argc ; ++i ) { if ( 0 == strcasecmp( argv[i] , "--threads" ) ) { params.use_threads = atoi( argv[++i] ); @@ -77,7 +113,6 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char else if ( 0 == strcasecmp( argv[i] , "--repeat" ) ) { params.repeat = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "--chunksize" ) ) { params.chunk_size = atoi( argv[++i] ) ; } @@ -122,6 +157,11 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char else if ( 0 == strcasecmp( argv[i] , "COLORING_VBDBIT" ) ) { params.algorithm = 8; } + else if ( 0 == strcasecmp( argv[i], "--help") || 0 == strcasecmp(argv[i], "-h") ) + { + print_options(std::cout, argv[0]); + return 1; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; print_options(); From 45d9bb61b3efe007386474cd57feed150e902513 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 27 Mar 2019 15:19:44 -0600 Subject: [PATCH 151/190] Add --help to distance-1 graph coloring example --- perf_test/graph/KokkosGraph_color.cpp | 52 +++++++++++++++++++++++---- 1 file changed, 46 insertions(+), 6 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index ada0009ebe..ff5f4ab49e 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -57,10 +57,46 @@ -void print_options(){ - +void print_options(std::ostream &os, const char *app_name, unsigned int indent = 0) +{ + std::string spaces(indent, ' '); + os << "Usage:" << std::endl + << spaces << " " << app_name << " [parameters]" << std::endl + << std::endl + << spaces << "Parameters:" << std::endl + << spaces << " Parallelism (select one of the following):" << std::endl + << spaces << " --serial Execute serially." << std::endl + << spaces << " --threads Use N posix threads." << std::endl + << spaces << " --openmp Use OpenMP with N threads." << std::endl + << spaces << " --cuda Use CUDA" << std::endl + << std::endl + << spaces << " Required Parameters:" << std::endl + << spaces << " --amtx Input file in Matrix Market format (.mtx)." << std::endl + << std::endl + << spaces << " --algorithm Set the algorithm to use. Allowable values are:" << std::endl + << spaces << " COLORING_DEFAULT - Use the default coloring method, architecture dependent." << std::endl + << spaces << " COLORING_SERIAL - Use the serial algorithm." << std::endl + << spaces << " COLORING_VB - Use the parallel vertex-based method." << std::endl + << spaces << " COLORING_VBBIT - Use the parallel vertex-based with bit vectors method." << std::endl + << spaces << " COLORING_EB - Use edge based method." << std::endl + << spaces << " COLORING_VBD - Use the vertex-based deterministic method." << std::endl + << spaces << " COLORING_VBDBIT - Use the vertex-based deterministic with bit vectors method." << std::endl + << std::endl + << spaces << " Optional Parameters:" << std::endl + << spaces << " --repeat Set number of test repetitions (Default: 1) " << std::endl + << spaces << " --verbose Enable verbose mode (record and print timing + extra information)" << std::endl + << spaces << " --chunksize Set the chunk size." << std::endl + << spaces << " --dynamic Use dynamic scheduling." << std::endl + << spaces << " --teamsize Set the team size." << std::endl + << spaces << " --vectorsize Set the vector size." << std::endl + << spaces << " --help Print out command line help." << std::endl + << spaces << " " << std::endl; } -int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv){ + + + +int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) +{ for ( int i = 1 ; i < argc ; ++i ) { if ( 0 == strcasecmp( argv[i] , "--threads" ) ) { params.use_threads = atoi( argv[++i] ); @@ -77,7 +113,6 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char else if ( 0 == strcasecmp( argv[i] , "--repeat" ) ) { params.repeat = atoi( argv[++i] ); } - else if ( 0 == strcasecmp( argv[i] , "--chunksize" ) ) { params.chunk_size = atoi( argv[++i] ) ; } @@ -122,15 +157,20 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char else if ( 0 == strcasecmp( argv[i] , "COLORING_VBDBIT" ) ) { params.algorithm = 8; } + else if ( 0 == strcasecmp( argv[i], "--help") || 0 == strcasecmp(argv[i], "-h") ) + { + print_options(std::cout, argv[0]); + return 1; + } else { std::cerr << "2-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; - print_options(); + print_options(std::cout, argv[0]); return 1; } } else { std::cerr << "3-Unrecognized command line argument #" << i << ": " << argv[i] << std::endl ; - print_options(); + print_options(std::cout, argv[0]); return 1; } } From a7b76a12b1c44173cbf3d4ab8d5a5b14a32257d9 Mon Sep 17 00:00:00 2001 From: William McLendon Date: Wed, 27 Mar 2019 16:09:29 -0600 Subject: [PATCH 152/190] clean up the --help option for D1 graph coloring example --- perf_test/graph/KokkosGraph_color.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index ff5f4ab49e..164d6bb62f 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -97,6 +97,9 @@ void print_options(std::ostream &os, const char *app_name, unsigned int indent = int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char **argv) { + bool got_required_param_amtx = false; + bool got_required_param_algorithm = false; + for ( int i = 1 ; i < argc ; ++i ) { if ( 0 == strcasecmp( argv[i] , "--threads" ) ) { params.use_threads = atoi( argv[++i] ); @@ -123,6 +126,7 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char params.vector_size = atoi( argv[++i] ) ; } else if ( 0 == strcasecmp( argv[i] , "--amtx" ) ) { + got_required_param_amtx = true; params.a_mtx_bin_file = argv[++i]; } else if ( 0 == strcasecmp( argv[i] , "--dynamic" ) ) { @@ -132,6 +136,7 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char params.verbose = 1; } else if ( 0 == strcasecmp( argv[i] , "--algorithm" ) ) { + got_required_param_algorithm = true; ++i; if ( 0 == strcasecmp( argv[i] , "COLORING_DEFAULT" ) ) { params.algorithm = 1; @@ -174,6 +179,24 @@ int parse_inputs (KokkosKernels::Experiment::Parameters ¶ms, int argc, char return 1; } } + if(!got_required_param_amtx) + { + std::cout << "Missing required parameter amtx" << std::endl << std::endl; + print_options(std::cout, argv[0]); + return 1; + } + if(!got_required_param_algorithm) + { + std::cout << "Missing required parameter algorithm" << std::endl << std::endl; + print_options(std::cout, argv[0]); + return 1; + } + if(!params.use_serial && !params.use_threads && !params.use_openmp && !params.use_cuda) + { + print_options(std::cout, argv[0]); + return 1; + } + return 0; } From 68dc5e02fb400eca8361f012cff2e98d6ea6f8ee Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 4 Apr 2019 10:15:57 -0600 Subject: [PATCH 153/190] KokkosBatched - putting ifdef guards for protecting lambda --- perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp | 6 +++++- perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp | 5 +++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index fedb357123..8bda30fec8 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -3,6 +3,9 @@ #include "impl/Kokkos_Timer.hpp" #include "Kokkos_Random.hpp" +#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) +#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) + /// KokkosKernels headers #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" @@ -615,4 +618,5 @@ int main(int argc, char* argv[]) { return 0; } - +#endif // defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) +#endif // !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp index 53d3c91e83..7b1a4d001d 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp @@ -3,6 +3,9 @@ #include "impl/Kokkos_Timer.hpp" #include "Kokkos_Random.hpp" +#if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) +#if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) + /// KokkosKernels headers #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" @@ -549,3 +552,5 @@ int main(int argc, char* argv[]) { } +#endif // defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) +#endif // !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) From 7ed5bab2571709707ce88c1dc1ba5a7de71e0497 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 4 Apr 2019 10:24:38 -0600 Subject: [PATCH 154/190] KokkosBatched - perf test needs a fake main --- .../KokkosBatched_Test_BlockTridiagDirect.cpp | 14 ++++++++++++-- .../KokkosBatched_Test_BlockTridiagJacobi.cpp | 14 ++++++++++---- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 8bda30fec8..6dfc04108f 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -5,6 +5,12 @@ #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) #if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) +#define KOKKOSBATCHED_TEST_BLOCKTRIDIAGDIRECT +#endif +#endif + + +#if defined(KOKKOSBATCHED_TEST_BLOCKTRIDIAGDIRECT) /// KokkosKernels headers #include "KokkosBatched_Util.hpp" @@ -618,5 +624,9 @@ int main(int argc, char* argv[]) { return 0; } -#endif // defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) -#endif // !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) +#else +int main() { + return 0; +} +#endif + diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp index 7b1a4d001d..349bd7f171 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp @@ -5,6 +5,11 @@ #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) #if !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) +#define KOKKOSBATCHED_TEST_BLOCKTRIDIAGJACOBI +#endif +#endif + +#if defined( KOKKOSBATCHED_TEST_BLOCKTRIDIAGJACOBI ) /// KokkosKernels headers #include "KokkosBatched_Util.hpp" @@ -550,7 +555,8 @@ int main(int argc, char* argv[]) { return 0; } - - -#endif // defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA) -#endif // !defined(KOKKOS_ENABLE_CUDA) || (8000 <= CUDA_VERSION) +#else +int main() { + return 0; +} +#endif From 418c04fe6285c6995024710317e4fe6fcbdbb720 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Thu, 4 Apr 2019 11:12:34 -0600 Subject: [PATCH 155/190] Add support for TPL MAGMA gesv --- src/dense/KokkosDense_gesv.hpp | 129 +++++++++ src/dense/impl/KokkosDense_gesv_impl.hpp | 61 +++++ src/dense/impl/KokkosDense_gesv_spec.hpp | 156 +++++++++++ .../tpls/KokkosDense_gesv_tpl_spec_avail.hpp | 107 ++++++++ .../tpls/KokkosDense_gesv_tpl_spec_decl.hpp | 258 ++++++++++++++++++ 5 files changed, 711 insertions(+) create mode 100644 src/dense/KokkosDense_gesv.hpp create mode 100644 src/dense/impl/KokkosDense_gesv_impl.hpp create mode 100644 src/dense/impl/KokkosDense_gesv_spec.hpp create mode 100644 src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp create mode 100644 src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp diff --git a/src/dense/KokkosDense_gesv.hpp b/src/dense/KokkosDense_gesv.hpp new file mode 100644 index 0000000000..ac2332c298 --- /dev/null +++ b/src/dense/KokkosDense_gesv.hpp @@ -0,0 +1,129 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +/// \file KokkosDense_gesv.hpp +/// \brief Local dense linear solve +/// +/// This file provides KokkosDense::gesv. This function performs a +/// local (no MPI) dense linear solve on a system of linear equations +/// A * X = B where A is a general N-by-N matrix and X and B are N-by-NRHS matrices. + +#ifndef KOKKOSDENSE_GESV_HPP_ +#define KOKKOSDENSE_GESV_HPP_ + +#include + +#include "KokkosDense_gesv_spec.hpp" + +namespace KokkosDense { + +/// \brief Solve the dense linear equation system A*X = B. +/// +/// \tparam AMatrix Input matrix/Output LU, as a 2-D Kokkos::View. +/// \tparam BXMV Input (right-hand side)/Output (solution) (multi)vector, as a 2-D Kokkos::View. +/// +/// \param pivot [in] "Y" (for partial pivoting), or "N" (for no pivoting). +/// \param A [in,out] On entry, the N-by-N matrix to be solved. On exit, the factors L and U from +/// the factorization A = P*L*U; the unit diagonal elements of L are not stored. +/// \param B [in,out] On entry, the right hand side (multi)vector B. On exit, the solution (multi)vector X. +/// +template +void +trsv (const char pivot[], + const AMatrix& A, + const BXMV& B) +{ + + static_assert (Kokkos::Impl::is_view::value, + "KokkosDense::gesv: A must be a Kokkos::View."); + static_assert (Kokkos::Impl::is_view::value, + "KokkosDense::gesv: B must be a Kokkos::View."); + static_assert (static_cast (AMatrix::rank) == 2, + "KokkosDense::gesv: A must have rank 2."); + static_assert (static_cast (BXMV::rank) == 1 || static_cast (BXMV::rank) == 2, + "KokkosDense::gesv: B must have either rank 1 or rank 2."); + + + // Check validity of pivot argument + bool valid_pivot = (pivot[0] == 'Y') || (pivot[0] == 'y') || + (pivot[0] == 'N') || (pivot[0] == 'n'); + if(!(valid_pivot)) { + std::ostringstream os; + os << "KokkosDense::gesv: pivot[0] = '" << pivot[0] << "'. " << + "Valid values include 'N' or 'n' (No pivoting), 'Y' or 'y' (partial pivoting)."; + Kokkos::Impl::throw_runtime_exception (os.str ()); + } + + // Check compatibility of dimensions at run time. + int64_t A0 = A.extent(0); + int64_t A1 = A.extent(1); + int64_t B0 = B.extent(0); + int64_t B1 = B.extent(1); + + if ( (A0 != A1) || + (A1 != B0) ) { + std::ostringstream os; + os << "KokkosDense::gesv: Dimensions of A, and B do not match: " + << " A: " << A.extent(0) << " x " << A.extent(1) + << " B: " << B.extent(0) << " x " << B.extent(1); + Kokkos::Impl::throw_runtime_exception (os.str ()); + } + + typedef Kokkos::View > AMatrix_Internal; + typedef Kokkos::View > BXMV_Internal; + AMatrix_Internal A_i = A; + BXMV_Internal B_i = B; + + KokkosDense::Impl::GESV::gesv (pivot, A_i, B_i); +} + +} // namespace KokkosDense + +#endif // KOKKOSDENSE_TRSV_HPP_ + diff --git a/src/dense/impl/KokkosDense_gesv_impl.hpp b/src/dense/impl/KokkosDense_gesv_impl.hpp new file mode 100644 index 0000000000..0e42211301 --- /dev/null +++ b/src/dense/impl/KokkosDense_gesv_impl.hpp @@ -0,0 +1,61 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSDENSE_IMPL_GESV_HPP_ +#define KOKKOSDENSE_IMPL_GESV_HPP_ + +/// \file KokkosDense_gesv_impl.hpp +/// \brief Implementation(s) of dense linear solve. + +#include +#include + +namespace KokkosDense { +namespace Impl { + +//NOTE: Might add the implementation of KokkosDense::gesv later + +} // namespace Impl +} // namespace KokkosDense + +#endif // KOKKOSDENSE_IMPL_GESV_HPP diff --git a/src/dense/impl/KokkosDense_gesv_spec.hpp b/src/dense/impl/KokkosDense_gesv_spec.hpp new file mode 100644 index 0000000000..96ed3d1cbf --- /dev/null +++ b/src/dense/impl/KokkosDense_gesv_spec.hpp @@ -0,0 +1,156 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#ifndef KOKKOSDENSE_IMPL_GESV_SPEC_HPP_ +#define KOKKOSDENSE_IMPL_GESV_SPEC_HPP_ + +#include +#include +#include + +// Include the actual functors +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +#include +#endif + +namespace KokkosDense { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct gesv_eti_spec_avail { + enum : bool { value = false }; +}; +} +} + +// +// Macro for declaration of full specialization availability +// KokkosBlas::Impl::GEMM. This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _INST macro below) across one or +// more .cpp files. +// +#define KOKKOSDENSE_GESV_ETI_SPEC_AVAIL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template<> \ + struct gesv_eti_spec_avail< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits > > \ + { enum : bool { value = true }; }; + +// Include the actual specialization declarations +#include +#include + +namespace KokkosDense { +namespace Impl { + +// Unification layer +/// \brief Implementation of KokkosDense::gesv. + +template::value, + bool eti_spec_avail = gesv_eti_spec_avail::value + > +struct GESV{ + static void + gesv (const char pivot[], + const AMatrix& A, + BXMV& B); +}; + + +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +//! Full specialization of gesv for multi vectors. +// Unification layer +template +struct GESV< AMatrix, BXMV, false, KOKKOSKERNELS_IMPL_COMPILE_LIBRARY>{ + static void + gesv (const char pivot[], + const AMatrix& A, + const BXMV& B) + { + //NOTE: Might add the implementation of KokkosDense::gesv later + } +}; + +#endif +}// namespace Impl +}// namespace KokkosDense + +// +// Macro for declaration of full specialization of +// KokkosDense::Impl::GESV. This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _DEF macro below) across one or +// more .cpp files. +// +#define KOKKOSDENSE_GESV_ETI_SPEC_DECL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE ) \ + extern template struct \ + GESV< Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true >; \ + +#define KOKKOSDENSE_TRSV_ETI_SPEC_INST( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template struct \ + GESV< Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true > ; + +#include +#include + + +#endif // KOKKOS_BLAS1_MV_IMPL_DOT_HPP_ diff --git a/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp b/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp new file mode 100644 index 0000000000..4cbb8cb715 --- /dev/null +++ b/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp @@ -0,0 +1,107 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKODENSE_GESV_TPL_SPEC_AVAIL_HPP_ +#define KOKKODENSE_GESV_TPL_SPEC_AVAIL_HPP_ + +namespace KokkosDense { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct gesv_tpl_spec_avail { + enum : bool { value = false }; +}; + +// MAGMA +#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA + +#define KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( SCALAR, LAYOUT, MEMSPACE ) \ +template \ +struct gesv_tpl_spec_avail< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + > { enum : bool { value = true }; }; + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif + +//#if defined (KOKKOSKERNELS_INST_DOUBLE) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_FLOAT) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif + +#endif + +} +} + +#endif diff --git a/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp b/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp new file mode 100644 index 0000000000..ae971453a2 --- /dev/null +++ b/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp @@ -0,0 +1,258 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSDENSE_GESV_TPL_SPEC_DECL_HPP_ +#define KOKKOSDENSE_GESV_TPL_SPEC_DECL_HPP_ + +// MAGMA +#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA +#include + +namespace KokkosDense { +namespace Impl { + +#define KOKKOSDENSE_DGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef double SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,double]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t LDA = static_cast (A.stride(0)); \ + magma_int_t LDB = static_cast (B.stride(0)); \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + magma_init(); \ + \ + magma_int_t *ipiv = NULL; \ + magma_int_t info = 0; \ + \ + magma_imalloc_cpu( &ipiv, N ); \ + \ + if(pivot_t) \ + magma_dgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + if(nopivot_t) \ + magma_dgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + magma_free_cpu( ipiv ); \ + \ + magma_finalize(); \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +#define KOKKOSDENSE_SGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef float SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,float]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t LDA = static_cast (A.stride(0)); \ + magma_int_t LDB = static_cast (B.stride(0)); \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + magma_init(); \ + \ + magma_int_t *ipiv = NULL; \ + magma_int_t info = 0; \ + \ + magma_imalloc_cpu( &ipiv, N ); \ + \ + if(pivot_t) \ + magma_sgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + if(nopivot_t) \ + magma_sgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + magma_free_cpu( ipiv ); \ + \ + magma_finalize(); \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +#define KOKKOSDENSE_ZGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef Kokkos::complex SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,complex]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t LDA = static_cast (A.stride(0)); \ + magma_int_t LDB = static_cast (B.stride(0)); \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + magma_init(); \ + \ + magma_int_t *ipiv = NULL; \ + magma_int_t info = 0; \ + \ + magma_imalloc_cpu( &ipiv, N ); \ + \ + if(pivot_t) \ + magma_zgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + if(nopivot_t) \ + magma_zgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + magma_free_cpu( ipiv ); \ + \ + magma_finalize(); \ + Kokkos::Profiling::popRegion(); \ + } \ +}; \ + +#define KOKKOSDENSE_CGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef Kokkos::complex SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,complex]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t LDA = static_cast (A.stride(0)); \ + magma_int_t LDB = static_cast (B.stride(0)); \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + magma_init(); \ + \ + magma_int_t *ipiv = NULL; \ + magma_int_t info = 0; \ + \ + magma_imalloc_cpu( &ipiv, N ); \ + \ + if(pivot_t) \ + magma_cgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + if(nopivot_t) \ + magma_cgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + magma_free_cpu( ipiv ); \ + \ + magma_finalize(); \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +KOKKOSDENSE_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSDENSE_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSDENSE_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSDENSE_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSDENSE_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSDENSE_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSDENSE_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSDENSE_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +} +} +#endif // KOKKOSKERNELS_ENABLE_TPL_MAGMA + +#endif From 863be2b6f910209c89c412a07bcb3ac108bec10c Mon Sep 17 00:00:00 2001 From: William McLendon Date: Thu, 4 Apr 2019 14:18:27 -0600 Subject: [PATCH 156/190] D2GC: Fix headers for Distance-1 use cases --- perf_test/graph/KokkosGraph_color.cpp | 3 +-- src/graph/impl/KokkosGraph_Distance1Color_impl.hpp | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/perf_test/graph/KokkosGraph_color.cpp b/perf_test/graph/KokkosGraph_color.cpp index 164d6bb62f..b88b962bd0 100644 --- a/perf_test/graph/KokkosGraph_color.cpp +++ b/perf_test/graph/KokkosGraph_color.cpp @@ -52,8 +52,7 @@ #include "KokkosKernels_IOUtils.hpp" #include "KokkosKernels_MyCRSMatrix.hpp" #include "KokkosKernels_TestParameters.hpp" -// #include "KokkosGraph_Distance1Color.hpp" -#include "KokkosGraph_graph_color.hpp" +#include "KokkosGraph_Distance1Color.hpp" diff --git a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp index ae994c6634..76eeb8debe 100644 --- a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp @@ -46,7 +46,7 @@ #include #include #include -#include "KokkosGraph_GraphColorHandle.hpp" +#include "KokkosGraph_Distance1ColorHandle.hpp" #include From dfaa6c1b0c5de652fbc0fd09b3fe3720fdc4f9ac Mon Sep 17 00:00:00 2001 From: crtrott Date: Mon, 8 Apr 2019 00:12:41 -0600 Subject: [PATCH 157/190] Fix two instances of using deprecated code (one of them inadvertenly) --- perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp | 4 ++-- perf_test/graph/KokkosGraph_color_d2.cpp | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 6dfc04108f..8a19f5c995 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -448,8 +448,8 @@ int main(int argc, char* argv[]) { UT.assign_data(&B(k-1, 0, 0)); UB.assign_data(&A(k, 0, 0)); - xt.assign_data(&x(k-1, 0, 0)); - xb.assign_data(&x(k, 0, 0)); + xt.assign_data(&x(k-1, 0)); + xb.assign_data(&x(k, 0)); Trsv Date: Mon, 8 Apr 2019 11:31:23 -0600 Subject: [PATCH 158/190] KokkosBatched - removing experimental namespace in src --- src/batched/KokkosBatched_AddRadial_Decl.hpp | 67 +- src/batched/KokkosBatched_AddRadial_Impl.hpp | 72 +- .../KokkosBatched_AddRadial_Internal.hpp | 98 +- ...kosBatched_ApplyGivens_Serial_Internal.hpp | 278 +- .../KokkosBatched_ApplyHouseholder_Decl.hpp | 42 +- ...osBatched_ApplyHouseholder_Serial_Impl.hpp | 91 +- ...tched_ApplyHouseholder_Serial_Internal.hpp | 192 +- .../KokkosBatched_ApplyQ_Serial_Internal.hpp | 257 +- src/batched/KokkosBatched_Copy_Decl.hpp | 120 +- src/batched/KokkosBatched_Copy_Impl.hpp | 116 +- src/batched/KokkosBatched_Copy_Internal.hpp | 138 +- .../KokkosBatched_Eigendecomposition_Decl.hpp | 99 +- ...Batched_Eigendecomposition_Serial_Impl.hpp | 79 +- ...hed_Eigendecomposition_Serial_Internal.hpp | 460 ++- ...osBatched_Eigendecomposition_Team_Impl.hpp | 66 +- ...kkosBatched_Eigenvalue_Serial_Internal.hpp | 373 ++- .../KokkosBatched_Francis_Serial_Internal.hpp | 363 ++- src/batched/KokkosBatched_Gemm_Decl.hpp | 144 +- .../KokkosBatched_Gemm_Serial_Impl.hpp | 822 +++--- .../KokkosBatched_Gemm_Serial_Internal.hpp | 211 +- src/batched/KokkosBatched_Gemm_Team_Impl.hpp | 465 ++- .../KokkosBatched_Gemm_Team_Internal.hpp | 261 +- src/batched/KokkosBatched_Gemv_Decl.hpp | 160 +- .../KokkosBatched_Gemv_Serial_Impl.hpp | 402 ++- .../KokkosBatched_Gemv_Serial_Internal.hpp | 147 +- src/batched/KokkosBatched_Gemv_Team_Impl.hpp | 238 +- .../KokkosBatched_Gemv_Team_Internal.hpp | 170 +- .../KokkosBatched_Givens_Serial_Internal.hpp | 100 +- ...atched_HessenbergFormQ_Serial_Internal.hpp | 81 +- ...HessenbergQR_WithShift_Serial_Internal.hpp | 235 +- ...kkosBatched_Hessenberg_Serial_Internal.hpp | 149 +- .../KokkosBatched_Householder_Decl.hpp | 34 +- .../KokkosBatched_Householder_Serial_Impl.hpp | 41 +- ...kosBatched_Householder_Serial_Internal.hpp | 112 +- .../KokkosBatched_InnerGemmFixA_Decl.hpp | 61 +- ...okkosBatched_InnerGemmFixA_Serial_Impl.hpp | 2238 ++++++++------- .../KokkosBatched_InnerGemmFixB_Decl.hpp | 63 +- ...okkosBatched_InnerGemmFixB_Serial_Impl.hpp | 1888 ++++++------ .../KokkosBatched_InnerGemmFixC_Decl.hpp | 111 +- ...okkosBatched_InnerGemmFixC_Serial_Impl.hpp | 2126 +++++++------- .../KokkosBatched_InnerGemmFixC_Team_Impl.hpp | 110 +- src/batched/KokkosBatched_InnerLU_Decl.hpp | 47 +- .../KokkosBatched_InnerLU_Serial_Impl.hpp | 441 ++- ...osBatched_InnerMultipleDotProduct_Decl.hpp | 69 +- ...ed_InnerMultipleDotProduct_Serial_Impl.hpp | 497 ++-- src/batched/KokkosBatched_InnerTrsm_Decl.hpp | 211 +- .../KokkosBatched_InnerTrsm_Serial_Impl.hpp | 2539 ++++++++--------- src/batched/KokkosBatched_InverseLU_Decl.hpp | 89 +- .../KokkosBatched_InverseLU_Serial_Impl.hpp | 92 +- src/batched/KokkosBatched_LU_Decl.hpp | 86 +- src/batched/KokkosBatched_LU_Serial_Impl.hpp | 121 +- .../KokkosBatched_LU_Serial_Internal.hpp | 202 +- src/batched/KokkosBatched_LU_Team_Impl.hpp | 67 +- .../KokkosBatched_LU_Team_Internal.hpp | 284 +- ...ftEigenvectorFromSchur_Serial_Internal.hpp | 247 +- .../KokkosBatched_Normalize_Internal.hpp | 94 +- ...KokkosBatched_QR_FormQ_Serial_Internal.hpp | 85 +- .../KokkosBatched_QR_Serial_Internal.hpp | 107 +- ...htEigenvectorFromSchur_Serial_Internal.hpp | 215 +- src/batched/KokkosBatched_Scale_Decl.hpp | 61 +- src/batched/KokkosBatched_Scale_Impl.hpp | 72 +- src/batched/KokkosBatched_Scale_Internal.hpp | 152 +- ...KokkosBatched_Schur2x2_Serial_Internal.hpp | 211 +- .../KokkosBatched_Schur_Serial_Internal.hpp | 428 ++- .../KokkosBatched_SetIdentity_Decl.hpp | 97 +- .../KokkosBatched_SetIdentity_Impl.hpp | 60 +- .../KokkosBatched_SetIdentity_Internal.hpp | 82 +- .../KokkosBatched_SetTriangular_Internal.hpp | 42 +- src/batched/KokkosBatched_Set_Decl.hpp | 59 +- src/batched/KokkosBatched_Set_Impl.hpp | 5 +- src/batched/KokkosBatched_Set_Internal.hpp | 152 +- ...kosBatched_ShiftedTrsv_Serial_Internal.hpp | 252 +- src/batched/KokkosBatched_SolveLU_Decl.hpp | 159 +- .../KokkosBatched_Test_BlockCrs_Util.hpp | 8 - src/batched/KokkosBatched_Trsm_Decl.hpp | 124 +- .../KokkosBatched_Trsm_Serial_Impl.hpp | 828 +++--- .../KokkosBatched_Trsm_Serial_Internal.hpp | 371 ++- src/batched/KokkosBatched_Trsm_Team_Impl.hpp | 419 ++- .../KokkosBatched_Trsm_Team_Internal.hpp | 503 ++-- src/batched/KokkosBatched_Trsv_Decl.hpp | 174 +- .../KokkosBatched_Trsv_Serial_Impl.hpp | 686 +++-- .../KokkosBatched_Trsv_Serial_Internal.hpp | 394 ++- src/batched/KokkosBatched_Trsv_Team_Impl.hpp | 389 ++- .../KokkosBatched_Trsv_Team_Internal.hpp | 427 ++- .../KokkosBatched_UpdateGivens_Internal.hpp | 46 +- src/batched/KokkosBatched_Util.cpp | 32 +- src/batched/KokkosBatched_Util.hpp | 945 +++--- src/batched/KokkosBatched_Vector.hpp | 243 +- src/batched/KokkosBatched_Vector_AVX256D.hpp | 2 +- src/batched/KokkosBatched_Vector_AVX512D.hpp | 2 +- src/batched/KokkosBatched_Vector_SIMD.hpp | 934 +++--- .../KokkosBatched_Vector_SIMD_Arith.hpp | 1071 ++++--- .../KokkosBatched_Vector_SIMD_Logical.hpp | 131 +- .../KokkosBatched_Vector_SIMD_Math.hpp | 375 ++- .../KokkosBatched_Vector_SIMD_Misc.hpp | 315 +- .../KokkosBatched_Vector_SIMD_Relation.hpp | 92 +- .../KokkosBatched_Vector_SIMD_View.hpp | 325 ++- ...Batched_WilkinsonShift_Serial_Internal.hpp | 91 +- 98 files changed, 14679 insertions(+), 14853 deletions(-) diff --git a/src/batched/KokkosBatched_AddRadial_Decl.hpp b/src/batched/KokkosBatched_AddRadial_Decl.hpp index fbe4fa2c17..dc9a73da95 100644 --- a/src/batched/KokkosBatched_AddRadial_Decl.hpp +++ b/src/batched/KokkosBatched_AddRadial_Decl.hpp @@ -8,40 +8,39 @@ #include "KokkosBatched_Vector.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// This add tiny values on diagonals so the absolute values of diagonals become larger - /// - - /// - /// Serial AddRadial - /// - - struct SerialAddRadial { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType tiny, - const AViewType &A); - }; - - /// - /// Team Set - /// - - template - struct TeamAddRadial { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType tiny, - const AViewType &A); - }; - - } + + /// + /// This add tiny values on diagonals so the absolute values of diagonals become larger + /// + + /// + /// Serial AddRadial + /// + + struct SerialAddRadial { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType tiny, + const AViewType &A); + }; + + /// + /// Team Set + /// + + template + struct TeamAddRadial { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType tiny, + const AViewType &A); + }; + } diff --git a/src/batched/KokkosBatched_AddRadial_Impl.hpp b/src/batched/KokkosBatched_AddRadial_Impl.hpp index 766e4fd952..10afb581c2 100644 --- a/src/batched/KokkosBatched_AddRadial_Impl.hpp +++ b/src/batched/KokkosBatched_AddRadial_Impl.hpp @@ -7,47 +7,45 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_AddRadial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== + + /// + /// Serial Impl + /// =========== - template - KOKKOS_INLINE_FUNCTION - int - SerialAddRadial:: - invoke(const ScalarType tiny, - const AViewType &A) { - return SerialAddRadialInternal:: - invoke((A.extent(0) < A.extent(1) ? A.extent(0) : A.extent(1)), - tiny, - A.data(), (A.stride_0() + A.stride_1())); - } - - /// - /// Team Impl - /// ========= + template + KOKKOS_INLINE_FUNCTION + int + SerialAddRadial:: + invoke(const ScalarType tiny, + const AViewType &A) { + return SerialAddRadialInternal:: + invoke((A.extent(0) < A.extent(1) ? A.extent(0) : A.extent(1)), + tiny, + A.data(), (A.stride_0() + A.stride_1())); + } + + /// + /// Team Impl + /// ========= - template - template - KOKKOS_INLINE_FUNCTION - int - TeamAddRadial:: - invoke(const MemberType &member, - const ScalarType tiny, - const AViewType &A) { - return TeamAddRadialInternal:: - invoke(member, - (A.extent(0) < A.extent(1) ? A.extent(0) : A.extent(1)), - tiny, - A.data(), (A.stride_0() + A.stride_1())); - } + template + template + KOKKOS_INLINE_FUNCTION + int + TeamAddRadial:: + invoke(const MemberType &member, + const ScalarType tiny, + const AViewType &A) { + return TeamAddRadialInternal:: + invoke(member, + (A.extent(0) < A.extent(1) ? A.extent(0) : A.extent(1)), + tiny, + A.data(), (A.stride_0() + A.stride_1())); + } - } // end namespace Experimental } //end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_AddRadial_Internal.hpp b/src/batched/KokkosBatched_AddRadial_Internal.hpp index f327d05a29..6fa51eda1d 100644 --- a/src/batched/KokkosBatched_AddRadial_Internal.hpp +++ b/src/batched/KokkosBatched_AddRadial_Internal.hpp @@ -6,68 +6,66 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - struct SerialAddRadialInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const ScalarType tiny, - /* */ ValueType *__restrict__ A, const int as) { - const auto abs_tiny = tiny > 0 ? tiny : -tiny; - const auto minus_abs_tiny = -abs_tiny; + + /// + /// Serial Internal Impl + /// ==================== + struct SerialAddRadialInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType tiny, + /* */ ValueType *__restrict__ A, const int as) { + const auto abs_tiny = tiny > 0 ? tiny : -tiny; + const auto minus_abs_tiny = -abs_tiny; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i::real(A[i*as]); + A[i*as] += ValueType(minus_abs_tiny)*ValueType(a_real < 0); + A[i*as] += ValueType( abs_tiny)*ValueType(a_real >= 0); + } + + return 0; + } + }; + + /// + /// Team Internal Impl + /// ================== + struct TeamAddRadialInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, + const ScalarType tiny, + /* */ ValueType *__restrict__ A, const int as) { + const auto abs_tiny = tiny > 0 ? tiny : -tiny; + const auto minus_abs_tiny = -abs_tiny; + + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,m), + [&](const int &i) { //const auto a_real = RealPart(A[i*as]); const auto a_real = Kokkos::Details::ArithTraits::real(A[i*as]); A[i*as] += ValueType(minus_abs_tiny)*ValueType(a_real < 0); A[i*as] += ValueType( abs_tiny)*ValueType(a_real >= 0); - } - - return 0; - } - }; + }); - /// - /// Team Internal Impl - /// ================== - struct TeamAddRadialInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, - const ScalarType tiny, - /* */ ValueType *__restrict__ A, const int as) { - const auto abs_tiny = tiny > 0 ? tiny : -tiny; - const auto minus_abs_tiny = -abs_tiny; - - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,m), - [&](const int &i) { - //const auto a_real = RealPart(A[i*as]); - const auto a_real = Kokkos::Details::ArithTraits::real(A[i*as]); - A[i*as] += ValueType(minus_abs_tiny)*ValueType(a_real < 0); - A[i*as] += ValueType( abs_tiny)*ValueType(a_real >= 0); - }); - - return 0; - } + return 0; + } - }; + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp index 70528f5af1..f45fbf8e23 100644 --- a/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyGivens_Serial_Internal.hpp @@ -6,178 +6,176 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialApplyLeftGivensInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair G, - const int n, - /* */ ValueType * a1t, const int a1ts, - /* */ ValueType * a2t, const int a2ts) { - typedef ValueType value_type; - if (n == 0) return 0; // quick return - if (G.first == value_type(1) && G.second == value_type(0)) return 0; - /// G = [ gamma -sigma; - /// sigma gamma ]; - /// A := G A - /// where gamma is G.first and sigma is G.second + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialApplyLeftGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair G, + const int n, + /* */ ValueType * a1t, const int a1ts, + /* */ ValueType * a2t, const int a2ts) { + typedef ValueType value_type; + if (n == 0) return 0; // quick return + if (G.first == value_type(1) && G.second == value_type(0)) return 0; + /// G = [ gamma -sigma; + /// sigma gamma ]; + /// A := G A + /// where gamma is G.first and sigma is G.second - const value_type gamma = G.first; - const value_type sigma = G.second; + const value_type gamma = G.first; + const value_type sigma = G.second; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair G, - const int m, - /* */ ValueType * a1, const int a1s, - /* */ ValueType * a2, const int a2s) { - typedef ValueType value_type; - if (m == 0) return 0; // quick return - if (G.first == value_type(1) && G.second == value_type(0)) return 0; - /// G = [ gamma -sigma; - /// sigma gamma ]; - /// A := A G' - /// where gamma is G.first and sigma is G.second + return 0; + } + }; + + struct SerialApplyRightGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair G, + const int m, + /* */ ValueType * a1, const int a1s, + /* */ ValueType * a2, const int a2s) { + typedef ValueType value_type; + if (m == 0) return 0; // quick return + if (G.first == value_type(1) && G.second == value_type(0)) return 0; + /// G = [ gamma -sigma; + /// sigma gamma ]; + /// A := A G' + /// where gamma is G.first and sigma is G.second - const value_type gamma = G.first; - const value_type sigma = G.second; + const value_type gamma = G.first; + const value_type sigma = G.second; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair &G12, - const int &m, const int &n, - /* */ ValueType *__restrict__ a1t, - /* */ ValueType *__restrict__ a2t, - /* */ ValueType *__restrict__ a1, - /* */ ValueType *__restrict__ a2, - const int &as0, const int &as1) { - typedef ValueType value_type; - if (G12.first == value_type(1) && G12.second == value_type(0)) return 0; - if (m == 0 && n == 0) return 0; // quick return - - const value_type gamma12 = G12.first; - const value_type sigma12 = G12.second; + return 0; + } + }; + + struct SerialApplyLeftRightGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G12, + const int &m, const int &n, + /* */ ValueType *__restrict__ a1t, + /* */ ValueType *__restrict__ a2t, + /* */ ValueType *__restrict__ a1, + /* */ ValueType *__restrict__ a2, + const int &as0, const int &as1) { + typedef ValueType value_type; + if (G12.first == value_type(1) && G12.second == value_type(0)) return 0; + if (m == 0 && n == 0) return 0; // quick return + + const value_type gamma12 = G12.first; + const value_type sigma12 = G12.second; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair &G12, - const Kokkos::pair &G13, - const int &m, const int &n, - /* */ ValueType *__restrict__ a1t, - /* */ ValueType *__restrict__ a2t, - /* */ ValueType *__restrict__ a3t, - /* */ ValueType *__restrict__ a1, - /* */ ValueType *__restrict__ a2, - /* */ ValueType *__restrict__ a3, - const int &as0, const int &as1) { - typedef ValueType value_type; - if (m == 0 && n == 0) return 0; // quick return - - const value_type gamma12 = G12.first; - const value_type sigma12 = G12.second; - const value_type gamma13 = G13.first; - const value_type sigma13 = G13.second; + return 0; + } + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &G12, + const Kokkos::pair &G13, + const int &m, const int &n, + /* */ ValueType *__restrict__ a1t, + /* */ ValueType *__restrict__ a2t, + /* */ ValueType *__restrict__ a3t, + /* */ ValueType *__restrict__ a1, + /* */ ValueType *__restrict__ a2, + /* */ ValueType *__restrict__ a3, + const int &as0, const int &as1) { + typedef ValueType value_type; + if (m == 0 && n == 0) return 0; // quick return + + const value_type gamma12 = G12.first; + const value_type sigma12 = G12.second; + const value_type gamma13 = G13.first; + const value_type sigma13 = G13.second; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - struct SerialApplyHouseholder { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const uViewType &u2, - const tauViewType &tau, - const AViewType - const wViewType &w); - }; - - } + + /// + /// Serial Householder + /// + + // level 1 operation (no blocking algorithm info avail) + template + struct SerialApplyHouseholder { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType + const wViewType &w); + }; + } + #endif diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp index c04fbc510d..472cbe16b1 100644 --- a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Impl.hpp @@ -7,57 +7,54 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Householder_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Impl - /// =========== - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialApplyHouseholder:: - invoke(const uViewType &u2, - const tauViewType &tau, - const AViewType &A, - const wViewType &w) { - return SerialApplyLeftHouseholderInternal:: - invoke(A.extent(0)-1, A.extent(1), - tau.data(), - u2.data(), u2.stride(0), - A.data(), A.stride(1), - A.data()+A.stride(0), A.stride(0), A.stride(1), - w.data()); - } + /// + /// Serial Impl + /// =========== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialApplyHouseholder:: + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType &A, + const wViewType &w) { + return SerialApplyLeftHouseholderInternal:: + invoke(A.extent(0)-1, A.extent(1), + tau.data(), + u2.data(), u2.stride(0), + A.data(), A.stride(1), + A.data()+A.stride(0), A.stride(0), A.stride(1), + w.data()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialApplyHouseholder:: - invoke(const uViewType &u2, - const tauViewType &tau, - const AViewType &A, - const wViewType &w) { - return SerialApplyRightHouseholderInternal:: - invoke(A.extent(0), A.extent(1)-1, - tau.data(), - u2.data(), u2.stride(0), - A.data(), A.stride(0), - A.data()+A.stride(1), A.stride(0), A.stride(1), - w.data()); - } - + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialApplyHouseholder:: + invoke(const uViewType &u2, + const tauViewType &tau, + const AViewType &A, + const wViewType &w) { + return SerialApplyRightHouseholderInternal:: + invoke(A.extent(0), A.extent(1)-1, + tau.data(), + u2.data(), u2.stride(0), + A.data(), A.stride(0), + A.data()+A.stride(1), A.stride(0), A.stride(1), + w.data()); } + } diff --git a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp index 53bb8f8f4d..71045b313c 100644 --- a/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyHouseholder_Serial_Internal.hpp @@ -6,110 +6,108 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialApplyLeftHouseholderInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int n, - const ValueType * tau, - /* */ ValueType * u2, const int u2s, - /* */ ValueType * a1t, const int a1ts, - /* */ ValueType * A2, const int as0, const int as1, - /* */ ValueType * w1t) { - typedef ValueType value_type; - - /// u2 m x 1 - /// a1t 1 x n - /// A2 m x n - - // apply a single householder transform H from the left to a row vector a1t - // and a matrix A2 - const value_type inv_tau = value_type(1)/(*tau); - - // compute the followings: - // a1t -= inv(tau)(a1t + u2'A2) - // A2 -= u2 inv(tau)(a1t + u2'A2) - - // w1t = a1t + u2'A2 = A2^T conj(u2) - // w1t /= tau - for (int j=0;j::conj(u2[i*u2s])*A2[i*as0+j*as1]; - w1t[j] = tmp*inv_tau; // /= (*tau); - } - - // a1t -= w1t (axpy) - for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int n, + const ValueType * tau, + /* */ ValueType * u2, const int u2s, + /* */ ValueType * a1t, const int a1ts, + /* */ ValueType * A2, const int as0, const int as1, + /* */ ValueType * w1t) { + typedef ValueType value_type; + + /// u2 m x 1 + /// a1t 1 x n + /// A2 m x n + + // apply a single householder transform H from the left to a row vector a1t + // and a matrix A2 + const value_type inv_tau = value_type(1)/(*tau); + + // compute the followings: + // a1t -= inv(tau)(a1t + u2'A2) + // A2 -= u2 inv(tau)(a1t + u2'A2) + + // w1t = a1t + u2'A2 = A2^T conj(u2) + // w1t /= tau + for (int j=0;j::conj(u2[i*u2s])*A2[i*as0+j*as1]; + w1t[j] = tmp*inv_tau; // /= (*tau); } - }; - - - struct SerialApplyRightHouseholderInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int n, - const ValueType * tau, - /* */ ValueType * u2, const int u2s, - /* */ ValueType * a1, const int a1s, - /* */ ValueType * A2, const int as0, const int as1, - /* */ ValueType * w1) { - typedef ValueType value_type; - /// u2 n x 1 - /// a1 m x 1 - /// A2 m x n - - // apply a single householder transform H from the left to a row vector a1t - // and a matrix A2 - const value_type inv_tau = value_type(1)/(*tau); + + // a1t -= w1t (axpy) + for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int n, + const ValueType * tau, + /* */ ValueType * u2, const int u2s, + /* */ ValueType * a1, const int a1s, + /* */ ValueType * A2, const int as0, const int as1, + /* */ ValueType * w1) { + typedef ValueType value_type; + /// u2 n x 1 + /// a1 m x 1 + /// A2 m x n + + // apply a single householder transform H from the left to a row vector a1t + // and a matrix A2 + const value_type inv_tau = value_type(1)/(*tau); - // compute the followings: - // a1 -= inv(tau)(a1 + A2 u2) - // A2 -= inv(tau)(a1 + A2 u2) u2' - - // w1 = a1 + A2 u2 - // w1 /= tau - for (int i=0;i::conj(u2[j*u2s]); + // a1 -= w1 (axpy) + for (int i=0;i::conj(u2[j*u2s]); + + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp index 190fee0c72..27d1ed8a0c 100644 --- a/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ApplyQ_Serial_Internal.hpp @@ -8,141 +8,138 @@ #include "KokkosBatched_ApplyHouseholder_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - - - struct SerialApplyQ_LeftNoTransForwardInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int n, - const int k, - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * B, const int bs0, const int bs1, - /* */ ValueType * w) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + + + struct SerialApplyQ_LeftNoTransForwardInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int n, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * B, const int bs0, const int bs1, + /* */ ValueType * w) { + typedef ValueType value_type; - /// Given a matrix A that includes a series of householder vectors, - /// it applies a unitary matrix Q to B from left without transpose - /// B = Q B = (H0 H1 H2 H3 ... H(k-1)) B - /// where - /// A is m x k (holding H0, H1 ... H(k-1) - /// t is k x 1 - /// B is m x n - - // partitions used for loop iteration - Partition2x2 A_part2x2(as0, as1); - Partition3x3 A_part3x3(as0, as1); - - Partition2x1 t_part2x1(ts); - Partition3x1 t_part3x1(ts); - - Partition2x1 B_part2x1(bs0); - Partition3x1 B_part3x1(bs0); - - // initial partition of A where ATL has a zero dimension - A_part2x2.partWithABR(A, m, k, m-k, 0); - t_part2x1.partWithAB (t, k, 0 ); - B_part2x1.partWithAB (B, m, m-k ); - - for (int m_A0=(k-1);m_A0>=0;--m_A0) { - // part 2x2 into 3x3 - A_part3x3.partWithATL(A_part2x2, 1, 1); - t_part3x1.partWithAT (t_part2x1, 1); - value_type *tau = t_part3x1.A1; - - B_part3x1.partWithAT (B_part2x1, 1); - const int m_A2 = m - m_A0 - 1; - /// ----------------------------------------------------- - // left apply householder to partitioned B1 and B2 - SerialApplyLeftHouseholderInternal::invoke(m_A2, n, - tau, - A_part3x3.A21, as0, - B_part3x1.A1, bs1, - B_part3x1.A2, bs0, bs1, - w); - - /// ----------------------------------------------------- - A_part2x2.mergeToABR(A_part3x3); - t_part2x1.mergeToAB (t_part3x1); - B_part2x1.mergeToAB (B_part3x1); - } - return 0; + /// Given a matrix A that includes a series of householder vectors, + /// it applies a unitary matrix Q to B from left without transpose + /// B = Q B = (H0 H1 H2 H3 ... H(k-1)) B + /// where + /// A is m x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x n + + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + Partition2x1 B_part2x1(bs0); + Partition3x1 B_part3x1(bs0); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithABR(A, m, k, m-k, 0); + t_part2x1.partWithAB (t, k, 0 ); + B_part2x1.partWithAB (B, m, m-k ); + + for (int m_A0=(k-1);m_A0>=0;--m_A0) { + // part 2x2 into 3x3 + A_part3x3.partWithATL(A_part2x2, 1, 1); + t_part3x1.partWithAT (t_part2x1, 1); + value_type *tau = t_part3x1.A1; + + B_part3x1.partWithAT (B_part2x1, 1); + const int m_A2 = m - m_A0 - 1; + /// ----------------------------------------------------- + // left apply householder to partitioned B1 and B2 + SerialApplyLeftHouseholderInternal::invoke(m_A2, n, + tau, + A_part3x3.A21, as0, + B_part3x1.A1, bs1, + B_part3x1.A2, bs0, bs1, + w); + + /// ----------------------------------------------------- + A_part2x2.mergeToABR(A_part3x3); + t_part2x1.mergeToAB (t_part3x1); + B_part2x1.mergeToAB (B_part3x1); } - }; - - struct SerialApplyQ_RightNoTransForwardInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int n, - const int k, - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * B, const int bs0, const int bs1, - /* */ ValueType * w) { - typedef ValueType value_type; + return 0; + } + }; + + struct SerialApplyQ_RightNoTransForwardInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int n, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * B, const int bs0, const int bs1, + /* */ ValueType * w) { + typedef ValueType value_type; - /// Given a matrix A that includes a series of householder vectors, - /// it applies a unitary matrix Q to B from left without transpose - /// B = B Q = B (H0 H1 H2 H3 ... H(k-1)) - /// where - /// A is n x k (holding H0, H1 ... H(k-1) - /// t is k x 1 - /// B is m x n - - // partitions used for loop iteration - Partition2x2 A_part2x2(as0, as1); - Partition3x3 A_part3x3(as0, as1); - - Partition2x1 t_part2x1(ts); - Partition3x1 t_part3x1(ts); - - Partition1x2 B_part1x2(bs1); - Partition1x3 B_part1x3(bs1); - - // initial partition of A where ATL has a zero dimension - A_part2x2.partWithATL(A, n, k, 0, 0); - t_part2x1.partWithAT (t, k, 0 ); - B_part1x2.partWithAL (B, n, 0 ); - - for (int n_A0=0;n_A0 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); + + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); + + Partition1x2 B_part1x2(bs1); + Partition1x3 B_part1x3(bs1); + + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, n, k, 0, 0); + t_part2x1.partWithAT (t, k, 0 ); + B_part1x2.partWithAL (B, n, 0 ); + + for (int n_A0=0;n_A0 - struct SerialCopy { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - /* */ BViewType &B); - }; - - /// - /// Team Copy - /// - - template - struct TeamCopy { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const BViewType &B); - }; - - - /// - /// Selective Interface - /// - template - struct Copy { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const BViewType &B) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialCopy::invoke(A, B); - } else if (std::is_same::value) { - r_val = TeamCopy::invoke(member, A, B); - } - return r_val; - } - }; + /// + /// Serial Copy + /// + + template + struct SerialCopy { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + /* */ BViewType &B); + }; + + /// + /// Team Copy + /// + + template + struct TeamCopy { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B); + }; + + + /// + /// Selective Interface + /// + template + struct Copy { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialCopy::invoke(A, B); + } else if (std::is_same::value) { + r_val = TeamCopy::invoke(member, A, B); + } + return r_val; + } + }; - } } #define KOKKOSBATCHED_SERIAL_COPY_MATRIX_NO_TRANSPOSE_INTERNAL_INVOKE(M,N,A,AS0,AS1,B,BS0,BS1) \ - KokkosBatched::Experimental::SerialCopyInternal \ + KokkosBatched::SerialCopyInternal \ ::invoke(M, N, A, AS0, AS1, B, BS0, BS1) #define KOKKOSBATCHED_TEAM_COPY_MATRIX_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,N,A,AS0,AS1,B,BS0,BS1) \ - KokkosBatched::Experimental::TeamCopyInternal \ + KokkosBatched::TeamCopyInternal \ ::invoke(MEMBER, M, N, A, AS0, AS1, B, BS0, BS1) #define KOKKOSBATCHED_SERIAL_COPY_VECTOR_INTERNAL_INVOKE(M,A,AS,B,BS) \ - KokkosBatched::Experimental::SerialCopyInternal \ + KokkosBatched::SerialCopyInternal \ ::invoke(M, A, AS, B, BS) #define KOKKOSBATCHED_TEAM_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,A,AS,B,BS) \ - KokkosBatched::Experimental::TeamCopyInternal \ + KokkosBatched::TeamCopyInternal \ ::invoke(MEMBER, M, A, AS, B, BS) #define KOKKOSBATCHED_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,MEMBER,M,A,AS,B,BS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_COPY_VECTOR_INTERNAL_INVOKE(M,A,AS,B,BS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_COPY_VECTOR_NO_TRANSPOSE_INTERNAL_INVOKE(MEMBER,M,A,AS,B,BS); \ } diff --git a/src/batched/KokkosBatched_Copy_Impl.hpp b/src/batched/KokkosBatched_Copy_Impl.hpp index 1935ec00bb..2fdb85a3b7 100644 --- a/src/batched/KokkosBatched_Copy_Impl.hpp +++ b/src/batched/KokkosBatched_Copy_Impl.hpp @@ -7,85 +7,83 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Copy_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== + + /// + /// Serial Impl + /// =========== - template<> + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialCopy:: + invoke(const AViewType &A, + /* */ BViewType &B) { + return SerialCopyInternal:: + invoke(A.extent(0), + A.extent(1), + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialCopy:: + invoke(const AViewType &A, + /* */ BViewType &B) { + return SerialCopyInternal:: + invoke(A.extent(1), + A.extent(0), + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + + + /// + /// Team Impl + /// ========= + + template + struct TeamCopy { template KOKKOS_INLINE_FUNCTION - int - SerialCopy:: - invoke(const AViewType &A, + static int + invoke(const MemberType &member, + const AViewType &A, /* */ BViewType &B) { - return SerialCopyInternal:: - invoke(A.extent(0), + return TeamCopyInternal:: + invoke(member, + A.extent(0), A.extent(1), A.data(), A.stride_0(), A.stride_1(), B.data(), B.stride_0(), B.stride_1()); } + }; - template<> + template + struct TeamCopy { template KOKKOS_INLINE_FUNCTION - int - SerialCopy:: - invoke(const AViewType &A, + static int + invoke(const MemberType &member, + const AViewType &A, /* */ BViewType &B) { - return SerialCopyInternal:: - invoke(A.extent(1), + return TeamCopyInternal:: + invoke(member, + A.extent(1), A.extent(0), A.data(), A.stride_1(), A.stride_0(), B.data(), B.stride_0(), B.stride_1()); } - - - /// - /// Team Impl - /// ========= - - template - struct TeamCopy { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - /* */ BViewType &B) { - return TeamCopyInternal:: - invoke(member, - A.extent(0), - A.extent(1), - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - - template - struct TeamCopy { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - /* */ BViewType &B) { - return TeamCopyInternal:: - invoke(member, - A.extent(1), - A.extent(0), - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + }; - } // end namespace Experimental } //end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Copy_Internal.hpp b/src/batched/KokkosBatched_Copy_Internal.hpp index 213785ebe2..a309b8425e 100644 --- a/src/batched/KokkosBatched_Copy_Internal.hpp +++ b/src/batched/KokkosBatched_Copy_Internal.hpp @@ -6,89 +6,87 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== + + /// + /// Serial Internal Impl + /// ==================== - struct SerialCopyInternal { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const int m, - const ValueType *__restrict__ A, const int as0, - /* */ ValueType *__restrict__ B, const int bs0) { + struct SerialCopyInternal { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int m, + const ValueType *__restrict__ A, const int as0, + /* */ ValueType *__restrict__ B, const int bs0) { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const int m, const int n, - const ValueType *__restrict__ A, const int as0, const int as1, - /* */ ValueType *__restrict__ B, const int bs0, const int bs1) { - if (as1 < as0) - for (int i=0;i + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int m, const int n, + const ValueType *__restrict__ A, const int as0, const int as1, + /* */ ValueType *__restrict__ B, const int bs0, const int bs1) { + if (as1 < as0) + for (int i=0;i - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, - const ValueType *__restrict__ A, const int as0, - /* */ ValueType *__restrict__ B, const int bs0) { + /// + /// Team Internal Impl + /// ================== + struct TeamCopyInternal { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, + const ValueType *__restrict__ A, const int as0, + /* */ ValueType *__restrict__ B, const int bs0) { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,m),[&](const int &i) { + B[i*bs0] = A[i*as0]; + }); + //member.team_barrier(); + return 0; + } + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, const int n, + const ValueType *__restrict__ A, const int as0, const int as1, + /* */ ValueType *__restrict__ B, const int bs0, const int bs1) { + if (m > n) { Kokkos::parallel_for (Kokkos::TeamThreadRange(member,0,m),[&](const int &i) { - B[i*bs0] = A[i*as0]; + SerialCopyInternal::invoke(n, A+i*as0, as1, B+i*bs0, bs1); + }); + } else { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,n),[&](const int &j) { + SerialCopyInternal::invoke(m, A+j*as1, as0, B+j*bs1, bs0); }); - //member.team_barrier(); - return 0; - } - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, - const ValueType *__restrict__ A, const int as0, const int as1, - /* */ ValueType *__restrict__ B, const int bs0, const int bs1) { - if (m > n) { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,m),[&](const int &i) { - SerialCopyInternal::invoke(n, A+i*as0, as1, B+i*bs0, bs1); - }); - } else { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,n),[&](const int &j) { - SerialCopyInternal::invoke(m, A+j*as1, as0, B+j*bs1, bs0); - }); - } - //member.team_barrier(); - return 0; } - }; + //member.team_barrier(); + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp index 1a36d243a7..4ab0dd186c 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Decl.hpp @@ -8,60 +8,59 @@ #include "KokkosBatched_Vector.hpp" namespace KokkosBatched { - namespace Experimental { - /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition - /// of the matrix. - /// - /// Parameters: - /// [in] member - /// Team interface only has this argument. Partial specialization can be applied for - /// a different type of team member. - /// [in/out]A - /// Real general nonsymmetric rank 2 view A(m x m). - /// A is first condensed to a upper Hessenberg form. Then, the Francis - /// double shift QR algorithm is applied to compute its Schur form. - /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. - /// [out]er, [out]ei - /// A real and imaginary eigenvalues, which forms er(m)+ei(m)i - /// For a complex eigen pair, it stores a+bi and a-bi consecutively. - /// [out]UL, [out]UR - /// Left/right eigenvectors are stored in (m x m) matrices. If zero span view is provided, - /// it does not compute the corresponding eigenvectors. However, both UL and UR cannot have - /// zero span. If eigenvalues are only requested, use the Eigenvalue interface which - /// simplifies computations - /// [out]W - /// 1D contiguous workspace. The minimum size is (2*m*m+5*m) where m is the dimension of matrix A. - struct SerialEigendecomposition { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - const EViewType &er, const EViewType &ei, - const UViewType &UL, const UViewType &UR, - const WViewType &W); - }; + /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition + /// of the matrix. + /// + /// Parameters: + /// [in] member + /// Team interface only has this argument. Partial specialization can be applied for + /// a different type of team member. + /// [in/out]A + /// Real general nonsymmetric rank 2 view A(m x m). + /// A is first condensed to a upper Hessenberg form. Then, the Francis + /// double shift QR algorithm is applied to compute its Schur form. + /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. + /// [out]er, [out]ei + /// A real and imaginary eigenvalues, which forms er(m)+ei(m)i + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [out]UL, [out]UR + /// Left/right eigenvectors are stored in (m x m) matrices. If zero span view is provided, + /// it does not compute the corresponding eigenvectors. However, both UL and UR cannot have + /// zero span. If eigenvalues are only requested, use the Eigenvalue interface which + /// simplifies computations + /// [out]W + /// 1D contiguous workspace. The minimum size is (2*m*m+5*m) where m is the dimension of matrix A. - template - struct TeamEigendecomposition { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const EViewType &er, const EViewType &ei, - const UViewType &UL, const UViewType &UR, - const WViewType &W); - }; + struct SerialEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W); + }; + + template + struct TeamEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W); + }; - }/// end namespace Experimental } /// end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp index 4b010dd325..b3854b941e 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Impl.hpp @@ -8,47 +8,46 @@ #include "KokkosBatched_Eigendecomposition_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== - - template - KOKKOS_INLINE_FUNCTION - int - SerialEigendecomposition:: - invoke(const AViewType &A, - const EViewType &er, const EViewType &ei, - const UViewType &UL, const UViewType &UR, - const WViewType &W) { - /// view checking - const int m = A.extent(0); - assert(m == int(A.extent(1)) && "Eigendecomposition: A is not square"); - assert(m == int(er.extent(0)) && "Eigendecomposition: Length of er does not match to A's dimension"); - assert(m == int(ei.extent(0)) && "Eigendecomposition: Length of ei does not match to A's dimension"); - assert(m == int(UL.extent(0)) && "Eigendecomposition: Length of UL does not match to A's dimension"); - assert(m == int(UL.extent(1)) && "Eigendecomposition: Width of UL does not match to A's dimension"); - assert(m == int(UR.extent(0)) && "Eigendecomposition: Length of UR does not match to A's dimension"); - assert(m == int(UR.extent(1)) && "Eigendecomposition: Width of UR does not match to A's dimension"); - assert(int(W.extent(0)) >= int(2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); - assert(int(W.stride(0)) == int(1) && "Eigendecomposition: Provided workspace is not contiguous"); + + /// + /// Serial Impl + /// =========== + + template + KOKKOS_INLINE_FUNCTION + int + SerialEigendecomposition:: + invoke(const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W) { + /// view checking + const int m = A.extent(0); + assert(m == int(A.extent(1)) && "Eigendecomposition: A is not square"); + assert(m == int(er.extent(0)) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == int(ei.extent(0)) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == int(UL.extent(0)) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == int(UL.extent(1)) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == int(UR.extent(0)) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == int(UR.extent(1)) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(int(W.extent(0)) >= int(2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(int(W.stride(0)) == int(1) && "Eigendecomposition: Provided workspace is not contiguous"); - /// static assert A,er,ei,UL,UR,W has the same value_type - /// static assert all views have the same memory space - return m ? SerialEigendecompositionInternal - ::invoke(A.extent(0), - A.data(), A.stride(0), A.stride(1), - er.data(), er.stride(0), - ei.data(), ei.stride(0), - UL.data(), UL.stride(0), UL.stride(1), - UR.data(), UR.stride(0), UR.stride(1), - W.data(), W.extent(0)) : 0; - } - - }/// end namespace Experimental + /// static assert A,er,ei,UL,UR,W has the same value_type + /// static assert all views have the same memory space + return m ? SerialEigendecompositionInternal + ::invoke(A.extent(0), + A.data(), A.stride(0), A.stride(1), + er.data(), er.stride(0), + ei.data(), ei.stride(0), + UL.data(), UL.stride(0), UL.stride(1), + UR.data(), UR.stride(0), UR.stride(1), + W.data(), W.extent(0)) : 0; + } + } /// end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp index 93a13e62f8..91f6843f81 100644 --- a/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigendecomposition_Serial_Internal.hpp @@ -16,282 +16,280 @@ #include "KokkosBatched_Gemm_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - struct SerialEigendecompositionInternal { - /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition - /// of the matrix. - /// - /// Parameters: - /// [in]m - /// A dimension of the square matrix H. - /// [in/out]A, [in]as0, [in]as1 - /// Real general nonsymmetric matrix A(m x m) with strides as0 and as1. - /// A is first condensed to a upper Hessenberg form. Then, the Francis - /// double shift QR algorithm is applied to compute its Schur form. - /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. - /// [out]er, [in]ers, [out]ei, [in]eis - /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. - /// For a complex eigen pair, it stores a+bi and a-bi consecutively. - /// [out]UL, [in]uls0, [in] uls1 - /// Left eigenvectors UL(m x m) with strides uls0 and uls1. When UL is NULL, the left - /// eigenvectors are not computed. - /// [out]UR, [in]urs0, [in] urs1 - /// Right eigenvectors UR(m x m) with strides urs0 and urs1. When UR is NULL, the right - /// eigenvectors are not computed. - /// [out]w, [in]wlen - /// Workspace - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - RealType * A, const int as0, const int as1, - RealType * er, const int ers, - RealType * ei, const int eis, - RealType * UL, const int uls0, const int uls1, - RealType * UR, const int urs0, const int urs1, - RealType * w, const int wlen) { - typedef RealType real_type; - typedef Kokkos::Details::ArithTraits ats; + /// + /// Serial Internal Impl + /// ==================== + + struct SerialEigendecompositionInternal { + /// Given a general nonsymmetric matrix A (m x m), it performs eigendecomposition + /// of the matrix. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]A, [in]as0, [in]as1 + /// Real general nonsymmetric matrix A(m x m) with strides as0 and as1. + /// A is first condensed to a upper Hessenberg form. Then, the Francis + /// double shift QR algorithm is applied to compute its Schur form. + /// On exit, A stores a quasi upper triangular matrix of the Schur decomposition. + /// [out]er, [in]ers, [out]ei, [in]eis + /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [out]UL, [in]uls0, [in] uls1 + /// Left eigenvectors UL(m x m) with strides uls0 and uls1. When UL is NULL, the left + /// eigenvectors are not computed. + /// [out]UR, [in]urs0, [in] urs1 + /// Right eigenvectors UR(m x m) with strides urs0 and urs1. When UR is NULL, the right + /// eigenvectors are not computed. + /// [out]w, [in]wlen + /// Workspace + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + RealType * A, const int as0, const int as1, + RealType * er, const int ers, + RealType * ei, const int eis, + RealType * UL, const int uls0, const int uls1, + RealType * UR, const int urs0, const int urs1, + RealType * w, const int wlen) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; - const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); - //const Kokkos::pair identity(one, zero); + const real_type one(1), zero(0), tol = 1e2*ats::epsilon(); + //const Kokkos::pair identity(one, zero); - /// step 0: input checking - assert( (wlen >= (2*m*m+5*m)) && "Eigendecomposition: workspace size is too small"); - real_type *w_now = w; - int wlen_now = wlen; - assert( (wlen_now >= 0) && "Eigendecomposition: workspace size is negative"); + /// step 0: input checking + assert( (wlen >= (2*m*m+5*m)) && "Eigendecomposition: workspace size is too small"); + real_type *w_now = w; + int wlen_now = wlen; + assert( (wlen_now >= 0) && "Eigendecomposition: workspace size is negative"); - const bool is_UL = UL != NULL, is_UR = UR != NULL; - const bool is_U = is_UL || is_UR; - assert( is_U && "Eigendecomposition: eigenvectors are not requested; consider to use SerialEigenvalueInternal"); + const bool is_UL = UL != NULL, is_UR = UR != NULL; + const bool is_U = is_UL || is_UR; + assert( is_U && "Eigendecomposition: eigenvectors are not requested; consider to use SerialEigenvalueInternal"); - real_type *QZ = w_now; w_now += (m*m); wlen_now -= (m*m); - assert( (wlen_now >= 0) && "Eigendecomposition: QZ allocation fails"); + real_type *QZ = w_now; w_now += (m*m); wlen_now -= (m*m); + assert( (wlen_now >= 0) && "Eigendecomposition: QZ allocation fails"); - const int qzs0 = m, qzs1 = 1, qzs = m+1; /// row major - const int as = as0+as1; + const int qzs0 = m, qzs1 = 1, qzs = m+1; /// row major + const int as = as0+as1; - /// step 1: Hessenberg reduction A = Q H Q^H - /// Q is stored in QZ + /// step 1: Hessenberg reduction A = Q H Q^H + /// Q is stored in QZ #if defined(KOKKOSKERNELS_ENABLE_TPL_MKL) && defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST) - { - real_type *t = w_now; w_now += m; wlen_now -= m; - assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t allocation fail"); + { + real_type *t = w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t allocation fail"); - if (as0 == 1 || as1 == 1) { /// if mkl can be interfaced, use it - const auto matrix_layout = ( as1 == 1 ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR ); - LAPACKE_dgehrd(matrix_layout, m, 1, m, A, m, t); + if (as0 == 1 || as1 == 1) { /// if mkl can be interfaced, use it + const auto matrix_layout = ( as1 == 1 ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR ); + LAPACKE_dgehrd(matrix_layout, m, 1, m, A, m, t); - SerialCopyInternal::invoke(m, m, QZ, qzs0, qzs1); - LAPACKE_dorghr(matrix_layout, m, 1, m, QZ, m, t); - } else { /// for arbitrary strides, there is no choice to use tpls - real_type *ww = w_now; w_now += m; wlen_now -= m; - assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace ww allocation fail"); - - SerialHessenbergInternal::invoke(m, m, - A, as0, as1, - t, 1, - ww); - - SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); - SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m-1, m-1, - A+as0, as0, as1, - t, 1, - QZ+qzs, qzs0, qzs1, - ww); - /// recovery of workspace for ww - w_now -= m; wlen_now += m; - } - /// recovery of workspace for t - w_now -= m; wlen_now += m; - - /// clean up H - SerialSetLowerTriangularInternal::invoke(m, m, - 2, - zero, - A, as0, as1); - } -#else - { - real_type *t = w_now; w_now += m; wlen_now -= m; + SerialCopyInternal::invoke(m, m, QZ, qzs0, qzs1); + LAPACKE_dorghr(matrix_layout, m, 1, m, QZ, m, t); + } else { /// for arbitrary strides, there is no choice to use tpls real_type *ww = w_now; w_now += m; wlen_now -= m; - assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t and ww allocation fail"); + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace ww allocation fail"); SerialHessenbergInternal::invoke(m, m, A, as0, as1, t, 1, ww); - + SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m-1, m-1, A+as0, as0, as1, t, 1, QZ+qzs, qzs0, qzs1, ww); + /// recovery of workspace for ww + w_now -= m; wlen_now += m; + } + /// recovery of workspace for t + w_now -= m; wlen_now += m; - /// clean up H - SerialSetLowerTriangularInternal::invoke(m, m, - 2, - zero, - A, as0, as1); + /// clean up H + SerialSetLowerTriangularInternal::invoke(m, m, + 2, + zero, + A, as0, as1); + } +#else + { + real_type *t = w_now; w_now += m; wlen_now -= m; + real_type *ww = w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Hessenberg reduction workspace t and ww allocation fail"); - /// recover workspace - w_now -= (2*m); wlen_now += (2*m); - } + SerialHessenbergInternal::invoke(m, m, + A, as0, as1, + t, 1, + ww); + + SerialSetIdentityInternal::invoke(m, QZ, qzs0, qzs1); + SerialApplyQ_LeftNoTransForwardInternal::invoke(m-1, m-1, m-1, + A+as0, as0, as1, + t, 1, + QZ+qzs, qzs0, qzs1, + ww); + + /// clean up H + SerialSetLowerTriangularInternal::invoke(m, m, + 2, + zero, + A, as0, as1); + + /// recover workspace + w_now -= (2*m); wlen_now += (2*m); + } #endif - /// step 2: Schur decomposition H = Z T Z^H - /// Z is applied to QZ - { - int r_val = 0; - real_type *ww = w_now; w_now += (5*m); wlen_now -= (5*m); - assert( (wlen_now >= 0) && "Eigendecomposition: Schur decomposition workspace ww allocation fails"); - do { - const bool restart = (r_val < 0); - r_val = SerialSchurInternal::invoke(m, - A, as0, as1, - QZ, qzs0, qzs1, - ww, 5*m, - restart); - } while (r_val < 0 && false); - // for a testing purpose, we run the Schur decomposition with a finite number of Francis iterations - w_now -= (5*m); wlen_now += (5*m); - } + /// step 2: Schur decomposition H = Z T Z^H + /// Z is applied to QZ + { + int r_val = 0; + real_type *ww = w_now; w_now += (5*m); wlen_now -= (5*m); + assert( (wlen_now >= 0) && "Eigendecomposition: Schur decomposition workspace ww allocation fails"); + do { + const bool restart = (r_val < 0); + r_val = SerialSchurInternal::invoke(m, + A, as0, as1, + QZ, qzs0, qzs1, + ww, 5*m, + restart); + } while (r_val < 0 && false); + // for a testing purpose, we run the Schur decomposition with a finite number of Francis iterations + w_now -= (5*m); wlen_now += (5*m); + } - /// Step 3: Extract iigenvalues and eigenvectors from T = V S V^-1 - /// - { - /// extract eigenvalues - real_type *AA = A-as1; - int *blks = (int*)w_now; w_now += m; wlen_now -= m; - assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace blks allocation fails"); + /// Step 3: Extract iigenvalues and eigenvectors from T = V S V^-1 + /// + { + /// extract eigenvalues + real_type *AA = A-as1; + int *blks = (int*)w_now; w_now += m; wlen_now -= m; + assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace blks allocation fails"); - { - int i=0; - for (;i<(m-1);) { - const real_type subdiag = ats::abs(AA[(i+1)*as]); - const real_type diag = A[i*as]; - if (subdiag < tol) { - er[i*ers] = diag; - ei[i*eis] = zero; - blks[i] = 1; - i+=1; - } else { - const real_type offdiag = ats::abs(A[i*as+as1]); - const real_type sqrt_mult_suboffdiags = ats::sqrt(subdiag*offdiag); - er[(i )*ers] = diag; - er[(i+1)*ers] = diag; - ei[(i )*eis] = sqrt_mult_suboffdiags; - ei[(i+1)*eis] = -sqrt_mult_suboffdiags; - blks[i ] = 2; - blks[i+1] = 2; /// consider backward iteration - i+=2; - } - } - if (i= 0) && "Eigendecomposition: Eigenvector workspace V allocation fails"); + { + real_type *V = w_now; w_now += (m*m); wlen_now -= (m*m); + assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace V allocation fails"); - const int vs0 = 1, vs1 = m; - real_type *ww = w_now; w_now += 2*m; wlen_now -= 2*m; - assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace w allocation fails"); + const int vs0 = 1, vs1 = m; + real_type *ww = w_now; w_now += 2*m; wlen_now -= 2*m; + assert( (wlen_now >= 0) && "Eigendecomposition: Eigenvector workspace w allocation fails"); - /// Right eigenvectors V - if (is_UR) { - SerialRightEigenvectorFromSchurInternal - ::invoke(m, - A, as0, as1, - V, vs0, vs1, - ww, - blks); - - /// QZ V - SerialGemmInternal:: - invoke(m, m, m, - one, - QZ, qzs0, qzs1, + /// Right eigenvectors V + if (is_UR) { + SerialRightEigenvectorFromSchurInternal + ::invoke(m, + A, as0, as1, V, vs0, vs1, - zero, - UR, urs0, urs1); - int j=0; - for (;j:: + invoke(m, m, m, + one, + QZ, qzs0, qzs1, + V, vs0, vs1, + zero, + UR, urs0, urs1); + int j=0; + for (;j:: - invoke(m, m, m, - one, + /// Left eigenvectors V stores V + if (is_UL) { + SerialLeftEigenvectorFromSchurInternal + ::invoke(m, + A, as0, as1, V, vs0, vs1, - QZ, qzs1, qzs0, - zero, - UL, uls0, uls1); + ww, + blks); + + /// V^-1 (QZ)^H + SerialGemmInternal:: + invoke(m, m, m, + one, + V, vs0, vs1, + QZ, qzs1, qzs0, + zero, + UL, uls0, uls1); - int i=0; - for (;i - struct TeamEigendecomposition { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const EViewType &er, const EViewType &ei, - const UViewType &UL, const UViewType &UR, - const WViewType &W) { - /// view checking - const int m = A.extent(0); - assert(m == A.extent(1) && "Eigendecomposition: A is not square"); - assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); - assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); - assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); - assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); - assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); - assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); - assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); - assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); - - return 0; - } - }; + /// + /// Team Impl + /// ========= + + template + struct TeamEigendecomposition { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const EViewType &er, const EViewType &ei, + const UViewType &UL, const UViewType &UR, + const WViewType &W) { + /// view checking + const int m = A.extent(0); + assert(m == A.extent(1) && "Eigendecomposition: A is not square"); + assert(m == er.extent(0) && "Eigendecomposition: Length of er does not match to A's dimension"); + assert(m == ei.extent(0) && "Eigendecomposition: Length of ei does not match to A's dimension"); + assert(m == UL.extent(0) && "Eigendecomposition: Length of UL does not match to A's dimension"); + assert(m == UL.extent(1) && "Eigendecomposition: Width of UL does not match to A's dimension"); + assert(m == UR.extent(0) && "Eigendecomposition: Length of UR does not match to A's dimension"); + assert(m == UR.extent(1) && "Eigendecomposition: Width of UR does not match to A's dimension"); + assert(W.extent(0) >= (2*m*m+5*m) && "Eigendecomposition: workspace size is too small"); + assert(W.stride(0) == 1 && "Eigendecomposition: Provided workspace is not contiguous"); + + return 0; + } + }; - }/// end namespace Experimental } /// end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp index bd1cecb5c8..74061d2871 100644 --- a/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Eigenvalue_Serial_Internal.hpp @@ -11,214 +11,211 @@ #include "KokkosBatched_Francis_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialEigenvalueInternal { - /// Given a strictly Hessenberg matrix H (m x m), this computes all eigenvalues - /// using the Francis method and stores them into a vector e. This routine does - /// not scale nor balance the matrix for the numerical stability. - /// - /// Parameters: - /// [in]m - /// A dimension of the square matrix H. - /// [in/out]H, [in]hs0, [in]hs1 - /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. - /// Entering the routine, H is assumed to have a upper Hessenberg form, where - /// all subdiagonals are zero. The matrix is overwritten on exit. - /// [out]er, [in]ers, [out]ei, [in]eis - /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. - /// For a complex eigen pair, it stores a+bi and a-bi consecutively. - /// [in]restart(false) - /// With a restart option, the routine assume that the matrix H and the vector e - /// contain the partial results from the previous run. When m = 1 or 2, this option - /// won't work as the routine always computes the all eigenvalues. - /// [in]max_iteration(300) - /// Unlike LAPACK which uses various methods for different types of matrices, - /// this routine uses the Francis method only. A user can set the maximum number - /// of iterations. When it reaches the maximum iteration counts without converging - /// all eigenvalues, the routine returns -1. - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ RealType * H, const int hs0, const int hs1, - /* */ RealType * er, const int ers, - /* */ RealType * ei, const int eis, - const bool restart = false, - const int user_max_iteration = -1) { - typedef RealType real_type; - typedef Kokkos::Details::ArithTraits ats; - const real_type zero(0), nan(ats::nan()), tol = 1e2*ats::epsilon(); - const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; - - int r_val = 0; - if (restart) { - if (m <= 2) { - Kokkos::abort("Error: restart option cannot be used for m=1 or m=2"); - } - } else { - for (int i=0;i lambda1, lambda2; - SerialWilkinsonShiftInternal::invoke(H[0], H[hs1], - H[hs0], H[hs], - &lambda1, &lambda2, - &is_complex); - er[0] = lambda1.real(); ei[0] = lambda1.imag(); - er[1] = lambda2.real(); ei[1] = lambda2.imag(); - break; + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialEigenvalueInternal { + /// Given a strictly Hessenberg matrix H (m x m), this computes all eigenvalues + /// using the Francis method and stores them into a vector e. This routine does + /// not scale nor balance the matrix for the numerical stability. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]H, [in]hs0, [in]hs1 + /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. + /// Entering the routine, H is assumed to have a upper Hessenberg form, where + /// all subdiagonals are zero. The matrix is overwritten on exit. + /// [out]er, [in]ers, [out]ei, [in]eis + /// A complex vector er(m)+ei(m)i with a stride ers and eis to store computed eigenvalues. + /// For a complex eigen pair, it stores a+bi and a-bi consecutively. + /// [in]restart(false) + /// With a restart option, the routine assume that the matrix H and the vector e + /// contain the partial results from the previous run. When m = 1 or 2, this option + /// won't work as the routine always computes the all eigenvalues. + /// [in]max_iteration(300) + /// Unlike LAPACK which uses various methods for different types of matrices, + /// this routine uses the Francis method only. A user can set the maximum number + /// of iterations. When it reaches the maximum iteration counts without converging + /// all eigenvalues, the routine returns -1. + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType * H, const int hs0, const int hs1, + /* */ RealType * er, const int ers, + /* */ RealType * ei, const int eis, + const bool restart = false, + const int user_max_iteration = -1) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type zero(0), nan(ats::nan()), tol = 1e2*ats::epsilon(); + const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; + + int r_val = 0; + if (restart) { + if (m <= 2) { + Kokkos::abort("Error: restart option cannot be used for m=1 or m=2"); } - default: { - /// Francis method - int iter(0); /// iteration count - bool converge = false; /// bool to check all eigenvalues are converged - - while (!converge && iter < max_iteration) { - /// Step 1: find a set of unrevealed eigenvalues - int cnt = 1; + } else { + for (int i=0;i lambda1, lambda2; + SerialWilkinsonShiftInternal::invoke(H[0], H[hs1], + H[hs0], H[hs], + &lambda1, &lambda2, + &is_complex); + er[0] = lambda1.real(); ei[0] = lambda1.imag(); + er[1] = lambda2.real(); ei[1] = lambda2.imag(); + break; + } + default: { + /// Francis method + int iter(0); /// iteration count + bool converge = false; /// bool to check all eigenvalues are converged + + while (!converge && iter < max_iteration) { + /// Step 1: find a set of unrevealed eigenvalues + int cnt = 1; - /// find mbeg (first nonzero subdiag value) - for (;cnt tol) break; - } - const int mbeg = cnt-1; + /// find mbeg (first nonzero subdiag value) + for (;cnt tol) break; + } + const int mbeg = cnt-1; - /// find mend (first zero subdiag value) - for (;cnt lambda1, lambda2; - bool is_complex; - real_type *sub2x2 = H+(mend-2)*hs; - if (2 == mdiff) { - SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], - sub2x2[hs0], sub2x2[hs], - &lambda1, &lambda2, - &is_complex); - sub2x2[hs0] = zero; - - /// eigenvalues are from wilkinson shift - er[(mbeg+0)*ers] = lambda1.real(); ei[(mbeg+0)*eis] = lambda1.imag(); - er[(mbeg+1)*ers] = lambda2.real(); ei[(mbeg+1)*eis] = lambda2.imag(); - } else { - SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], - sub2x2[hs0], sub2x2[hs], - &lambda1, &lambda2, - &is_complex); + { + /// find a complex eigen pair + Kokkos::complex lambda1, lambda2; + bool is_complex; + real_type *sub2x2 = H+(mend-2)*hs; + if (2 == mdiff) { + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); + sub2x2[hs0] = zero; + + /// eigenvalues are from wilkinson shift + er[(mbeg+0)*ers] = lambda1.real(); ei[(mbeg+0)*eis] = lambda1.imag(); + er[(mbeg+1)*ers] = lambda2.real(); ei[(mbeg+1)*eis] = lambda2.imag(); + } else { + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); - SerialFrancisInternal::invoke(0, mdiff, mdiff, - H+hs*mbeg, hs0, hs1, - lambda1, lambda2, - is_complex); - /* */ auto &val1 = *(sub2x2+hs0); - /* */ auto &val2 = *(sub2x2-hs1); - const auto abs_val1 = ats::abs(val1); - const auto abs_val2 = ats::abs(val2); - - /// convergence check - if (abs_val1 < tol) { - er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; - val1 = zero; - } else if (abs_val2 < tol) { - er[(mend-2)*ers] = lambda1.real(); ei[(mend-2)*eis] = lambda1.imag(); - er[(mend-1)*ers] = lambda2.real(); ei[(mend-1)*eis] = lambda2.imag(); - - val1 = zero; - val2 = zero; - } + SerialFrancisInternal::invoke(0, mdiff, mdiff, + H+hs*mbeg, hs0, hs1, + lambda1, lambda2, + is_complex); + /* */ auto &val1 = *(sub2x2+hs0); + /* */ auto &val2 = *(sub2x2-hs1); + const auto abs_val1 = ats::abs(val1); + const auto abs_val2 = ats::abs(val2); + + /// convergence check + if (abs_val1 < tol) { + er[(mend-1)*ers] = sub2x2[hs]; ei[(mend-1)*eis] = zero; + val1 = zero; + } else if (abs_val2 < tol) { + er[(mend-2)*ers] = lambda1.real(); ei[(mend-2)*eis] = lambda1.imag(); + er[(mend-1)*ers] = lambda2.real(); ei[(mend-1)*eis] = lambda2.imag(); + + val1 = zero; + val2 = zero; } } + } # endif - } else { - /// all eigenvalues are converged - converge = true; - } - ++iter; - } - /// Step 3: record missing real eigenvalues from the diagonals - if (converge) { - // record undetected eigenvalues - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ RealType * H, const int hs0, const int hs1, - /* */ Kokkos::complex * e, const int es, - const int max_iteration = 300, - const RealType user_tolerence = RealType(-1), - const bool restart = false) { - RealType * er = (RealType*)e; - RealType * ei = er+1; - const int two_es = 2*es; - return invoke(m, - H, hs0, hs1, - er, two_es, - ei, two_es, - user_tolerence, - restart, - max_iteration); + /// Step 3: record missing real eigenvalues from the diagonals + if (converge) { + // record undetected eigenvalues + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType * H, const int hs0, const int hs1, + /* */ Kokkos::complex * e, const int es, + const int max_iteration = 300, + const RealType user_tolerence = RealType(-1), + const bool restart = false) { + RealType * er = (RealType*)e; + RealType * ei = er+1; + const int two_es = 2*es; + return invoke(m, + H, hs0, hs1, + er, two_es, + ei, two_es, + user_tolerence, + restart, + max_iteration); + } + }; - }/// end namespace Experimental } /// end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp index b1e55a543e..78041b82eb 100644 --- a/src/batched/KokkosBatched_Francis_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Francis_Serial_Internal.hpp @@ -9,206 +9,205 @@ #include "KokkosBatched_ApplyGivens_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialFrancisInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int mbeg, const int mend, const int morg, - /* */ ValueType * HH, const int hs0, const int hs1, - const Kokkos::complex lambda1, - const Kokkos::complex lambda2, - const bool is_complex, - /* */ Kokkos::pair * GG, const bool request_schur) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialFrancisInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const Kokkos::complex lambda1, + const Kokkos::complex lambda2, + const bool is_complex, + /* */ Kokkos::pair * GG, const bool request_schur) { + typedef ValueType value_type; - const int hs = hs0+hs1; - const value_type one(1), zero(0); - const Kokkos::pair identity(one,zero); + const int hs = hs0+hs1; + const value_type one(1), zero(0); + const Kokkos::pair identity(one,zero); - /// redefine variables - const int m = mend-mbeg, mrst = morg-mend, mbeg_mult_hs0 = mbeg*hs0; - value_type *H = HH+hs*mbeg; + /// redefine variables + const int m = mend-mbeg, mrst = morg-mend, mbeg_mult_hs0 = mbeg*hs0; + value_type *H = HH+hs*mbeg; - /// initialize Gs - Kokkos::pair *Gs = NULL; - if (request_schur) { - Gs = (Kokkos::pair *)(GG+mbeg*2); - for (int i=0;i *Gs = NULL; + if (request_schur) { + Gs = (Kokkos::pair *)(GG+mbeg*2); + for (int i=0;i G[2]; + /// Given a strict Hessenberg matrix H (m x m), + /// it computes a single implicit QR step with a given shift + /// - it assumes H has zeros on subdiagonal entries ( + /// givens rotation is defined as G = [gamma -sigma + /// sigma gamma] + /// G' [chi1 chi2]^t = [alpha 0]^T + /// where G is stored as a pair of gamma and sigma + Kokkos::pair G[2]; - /// 0. compute 1st double shift vector - value_type v[3]; - { - // this needs m>=3 - // v = M e_1 = (H*H - 2 Re(lambda) H + |lambda|^2 I)e_1 - value_type s, t; - const value_type - h00 = H[0*hs0+0*hs1], h01 = H[0*hs0+1*hs1], - h10 = H[1*hs0+0*hs1], h11 = H[1*hs0+1*hs1], - /* */ h21 = H[2*hs0+1*hs1]; - if (is_complex) { - s = 2*lambda1.real(); - t = lambda1.real()*lambda1.real()+lambda1.imag()*lambda1.imag(); - } else { - const value_type val = H[(m-1)*hs]; - const auto dist_lambda1 = Kokkos::Details::ArithTraits::abs(lambda1.real() - val); - const auto dist_lambda2 = Kokkos::Details::ArithTraits::abs(lambda2.real() - val); - const value_type lambda = dist_lambda1 < dist_lambda2 ? lambda1.real() : lambda2.real(); - s = 2*lambda; - t = lambda*lambda; - } - v[0] = h00*h00+h01*h10 /* H^2 e_1 */ - s*h00 /* 2 Re(lambda) */ + t; - v[1] = h10*h00+h11*h10 /* */ - s*h10; - v[2] = h21*h10; + /// 0. compute 1st double shift vector + value_type v[3]; + { + // this needs m>=3 + // v = M e_1 = (H*H - 2 Re(lambda) H + |lambda|^2 I)e_1 + value_type s, t; + const value_type + h00 = H[0*hs0+0*hs1], h01 = H[0*hs0+1*hs1], + h10 = H[1*hs0+0*hs1], h11 = H[1*hs0+1*hs1], + /* */ h21 = H[2*hs0+1*hs1]; + if (is_complex) { + s = 2*lambda1.real(); + t = lambda1.real()*lambda1.real()+lambda1.imag()*lambda1.imag(); + } else { + const value_type val = H[(m-1)*hs]; + const auto dist_lambda1 = Kokkos::Details::ArithTraits::abs(lambda1.real() - val); + const auto dist_lambda2 = Kokkos::Details::ArithTraits::abs(lambda2.real() - val); + const value_type lambda = dist_lambda1 < dist_lambda2 ? lambda1.real() : lambda2.real(); + s = 2*lambda; + t = lambda*lambda; } + v[0] = h00*h00+h01*h10 /* H^2 e_1 */ - s*h00 /* 2 Re(lambda) */ + t; + v[1] = h10*h00+h11*h10 /* */ - s*h10; + v[2] = h21*h10; + } - /// 1. compute the first two givens rotations that introduces a bulge - { - SerialGivensInternal::invoke(v[0], v[1], - &G[0], - &v[0]); - SerialGivensInternal::invoke(v[0], v[2], - &G[1], - &v[0]); - // record - if (request_schur) { - Gs[0] = G[0]; - Gs[1] = G[1]; - } - - // apply G' from left and right - G[0].second = -G[0].second; - G[1].second = -G[1].second; - - const int mm = m < 4 ? m : 4, nn = m; - value_type *Hs = H-mbeg_mult_hs0; - SerialApplyLeftRightGivensInternal - ::invoke (G[0], G[1], - mm+mbeg, nn+mrst, - H, H +hs0,H +2*hs0, - Hs, Hs+hs1,Hs+2*hs1, - hs0, hs1); + /// 1. compute the first two givens rotations that introduces a bulge + { + SerialGivensInternal::invoke(v[0], v[1], + &G[0], + &v[0]); + SerialGivensInternal::invoke(v[0], v[2], + &G[1], + &v[0]); + // record + if (request_schur) { + Gs[0] = G[0]; + Gs[1] = G[1]; } - /// 1. chase the bulge - - // partitions used for loop iteration - Partition2x2 H_part2x2(hs0, hs1); - Partition3x3 H_part3x3(hs0, hs1); - - // initial partition of A where ATL has a zero dimension - int m_htl = 1; - H_part2x2.partWithATL(H, m, m, m_htl, m_htl); - for (;m_htl<(m-2);++m_htl) { - // part 2x2 into 3x3 - H_part3x3.partWithABR(H_part2x2, 1, 1); - /// ----------------------------------------------------- - value_type *chi1 = H_part3x3.A11-hs1; - value_type *chi2 = chi1+hs0; - value_type *chi3 = chi2+hs0; - - SerialGivensInternal::invoke(*chi1, *chi2, - &G[0], - chi1); *chi2 = zero; - SerialGivensInternal::invoke(*chi1, *chi3, - &G[1], - chi1); *chi3 = zero; - // record - if (request_schur) { - Gs[2*m_htl ] = G[0]; - Gs[2*m_htl+1] = G[1]; - } - - G[0].second = -G[0].second; - G[1].second = -G[1].second; - - const int nn = m-m_htl, mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; - value_type *a1t = H_part3x3.A11; - value_type *a2t = a1t+hs0; - value_type *a3t = a2t+hs0; - value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; - value_type *a2 = a1+hs1; - value_type *a3 = a2+hs1; - - SerialApplyLeftRightGivensInternal - ::invoke (G[0], G[1], - mm+mbeg, nn+mrst, - a1t, a2t, a3t, - a1, a2, a3, - hs0, hs1); - /// ----------------------------------------------------- - H_part2x2.mergeToATL(H_part3x3); - } + // apply G' from left and right + G[0].second = -G[0].second; + G[1].second = -G[1].second; + + const int mm = m < 4 ? m : 4, nn = m; + value_type *Hs = H-mbeg_mult_hs0; + SerialApplyLeftRightGivensInternal + ::invoke (G[0], G[1], + mm+mbeg, nn+mrst, + H, H +hs0,H +2*hs0, + Hs, Hs+hs1,Hs+2*hs1, + hs0, hs1); + } - // last 3x3 block - { - // part 2x2 into 3x3 - H_part3x3.partWithABR(H_part2x2, 1, 1); - /// ----------------------------------------------------- - value_type *chi1 = H_part3x3.A11-hs1; - value_type *chi2 = chi1+hs0; - SerialGivensInternal::invoke(*chi1, *chi2, - &G[0], - chi1); *chi2 = zero; + /// 1. chase the bulge + + // partitions used for loop iteration + Partition2x2 H_part2x2(hs0, hs1); + Partition3x3 H_part3x3(hs0, hs1); + + // initial partition of A where ATL has a zero dimension + int m_htl = 1; + H_part2x2.partWithATL(H, m, m, m_htl, m_htl); + for (;m_htl<(m-2);++m_htl) { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + /// ----------------------------------------------------- + value_type *chi1 = H_part3x3.A11-hs1; + value_type *chi2 = chi1+hs0; + value_type *chi3 = chi2+hs0; + + SerialGivensInternal::invoke(*chi1, *chi2, + &G[0], + chi1); *chi2 = zero; + SerialGivensInternal::invoke(*chi1, *chi3, + &G[1], + chi1); *chi3 = zero; + // record + if (request_schur) { Gs[2*m_htl ] = G[0]; - Gs[2*m_htl+1] = identity; - - G[0].second = -G[0].second; - - const int mm = m, nn = 2; - value_type *a1t = H_part3x3.A11; - value_type *a2t = a1t+hs0; - value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; - value_type *a2 = a1+hs1; - SerialApplyLeftRightGivensInternal - ::invoke (G[0], - mm+mbeg, nn+mrst, - a1t, a2t, - a1, a2, - hs0, hs1); - - /// ----------------------------------------------------- - H_part2x2.mergeToATL(H_part3x3); + Gs[2*m_htl+1] = G[1]; } - return 0; + G[0].second = -G[0].second; + G[1].second = -G[1].second; + + const int nn = m-m_htl, mtmp = m_htl+4, mm = mtmp < m ? mtmp : m; + value_type *a1t = H_part3x3.A11; + value_type *a2t = a1t+hs0; + value_type *a3t = a2t+hs0; + value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; + value_type *a2 = a1+hs1; + value_type *a3 = a2+hs1; + + SerialApplyLeftRightGivensInternal + ::invoke (G[0], G[1], + mm+mbeg, nn+mrst, + a1t, a2t, a3t, + a1, a2, a3, + hs0, hs1); + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); } - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const int mbeg, const int mend, const int morg, - /* */ ValueType * HH, const int hs0, const int hs1, - const Kokkos::complex lambda1, - const Kokkos::complex lambda2, - const bool is_complex) { - return invoke(mbeg, mend, morg, - HH, hs0, hs1, - lambda1, lambda2, is_complex, - (Kokkos::pair*)NULL, false); + // last 3x3 block + { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + /// ----------------------------------------------------- + value_type *chi1 = H_part3x3.A11-hs1; + value_type *chi2 = chi1+hs0; + SerialGivensInternal::invoke(*chi1, *chi2, + &G[0], + chi1); *chi2 = zero; + Gs[2*m_htl ] = G[0]; + Gs[2*m_htl+1] = identity; + + G[0].second = -G[0].second; + + const int mm = m, nn = 2; + value_type *a1t = H_part3x3.A11; + value_type *a2t = a1t+hs0; + value_type *a1 = H_part3x3.A01-mbeg_mult_hs0; + value_type *a2 = a1+hs1; + SerialApplyLeftRightGivensInternal + ::invoke (G[0], + mm+mbeg, nn+mrst, + a1t, a2t, + a1, a2, + hs0, hs1); + + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); } - }; - }// end namespace Experimental + return 0; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const Kokkos::complex lambda1, + const Kokkos::complex lambda2, + const bool is_complex) { + return invoke(mbeg, mend, morg, + HH, hs0, hs1, + lambda1, lambda2, is_complex, + (Kokkos::pair*)NULL, false); + } + }; + } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Gemm_Decl.hpp b/src/batched/KokkosBatched_Gemm_Decl.hpp index a4c2ead53f..c54f52e5a0 100644 --- a/src/batched/KokkosBatched_Gemm_Decl.hpp +++ b/src/batched/KokkosBatched_Gemm_Decl.hpp @@ -8,84 +8,84 @@ #include "KokkosBatched_Vector.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Gemm - /// - template - struct SerialGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C); - }; + /// + /// Serial Gemm + /// - /// - /// Team Gemm - /// + template + struct SerialGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C); + }; - template - struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C); - }; + /// + /// Team Gemm + /// + template + struct TeamGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C); + }; - /// - /// Selective Interface - /// - template - struct Gemm { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialGemm::invoke(alpha, A, B, beta, C); - } else if (std::is_same::value) { - r_val = TeamGemm::invoke(member, alpha, A, B, beta, C); - } - return r_val; - } - }; - } + /// + /// Selective Interface + /// + template + struct Gemm { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialGemm::invoke(alpha, A, B, beta, C); + } else if (std::is_same::value) { + r_val = TeamGemm::invoke(member, alpha, A, B, beta, C); + } + return r_val; + } + }; + } + #endif diff --git a/src/batched/KokkosBatched_Gemm_Serial_Impl.hpp b/src/batched/KokkosBatched_Gemm_Serial_Impl.hpp index 92290d7e21..b3de167496 100644 --- a/src/batched/KokkosBatched_Gemm_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Gemm_Serial_Impl.hpp @@ -7,460 +7,458 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Gemm_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Impl - /// =========== - - /// - /// Implemented: - /// NT/NT, T/NT, NT/T, T/T - /// - /// Not yet immplemented (ConjTranspose): - /// CT/NT, NT/CT, CT/CT - /// - - /// - /// NT/NT - /// + + /// + /// Serial Impl + /// =========== + + /// + /// Implemented: + /// NT/NT, T/NT, NT/T, T/T + /// + /// Not yet immplemented (ConjTranspose): + /// CT/NT, NT/CT, CT/CT + /// + + /// + /// NT/NT + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - typedef typename CViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = C.dimension(0), - n = C.dimension(1), - k = A.dimension(1); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)B.data(), B.stride_1(), - beta, - (double*)C.data(), C.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)B.data(), B.stride_0(), - beta, - (double*)C.data(), C.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + typedef typename CViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = C.dimension(0), + n = C.dimension(1), + k = A.dimension(1); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)B.data(), B.stride_1(), + beta, + (double*)C.data(), C.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)B.data(), B.stride_0(), + beta, + (double*)C.data(), C.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - /// - /// T/NT - /// + /// + /// T/NT + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - typedef typename CViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = C.dimension(0), - n = C.dimension(1), - k = A.dimension(0); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)B.data(), B.stride_1(), - beta, - (double*)C.data(), C.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)B.data(), B.stride_0(), - beta, - (double*)C.data(), C.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + typedef typename CViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = C.dimension(0), + n = C.dimension(1), + k = A.dimension(0); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)B.data(), B.stride_1(), + beta, + (double*)C.data(), C.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)B.data(), B.stride_0(), + beta, + (double*)C.data(), C.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - /// - /// NT/T - /// + /// + /// NT/T + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - typedef typename CViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = C.dimension(0), - n = C.dimension(1), - k = A.dimension(1); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_TRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)B.data(), B.stride_1(), - beta, - (double*)C.data(), C.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_TRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)B.data(), B.stride_0(), - beta, - (double*)C.data(), C.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + typedef typename CViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = C.dimension(0), + n = C.dimension(1), + k = A.dimension(1); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_TRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)B.data(), B.stride_1(), + beta, + (double*)C.data(), C.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_TRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)B.data(), B.stride_0(), + beta, + (double*)C.data(), C.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - /// - /// T/T - /// + /// + /// T/T + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - typedef typename CViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = C.dimension(0), - n = C.dimension(1), - k = A.dimension(0); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_TRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)B.data(), B.stride_1(), - beta, - (double*)C.data(), C.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_TRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)B.data(), B.stride_0(), - beta, - (double*)C.data(), C.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + typedef typename CViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = C.dimension(0), + n = C.dimension(1), + k = A.dimension(0); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1 && C.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_TRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)B.data(), B.stride_1(), + beta, + (double*)C.data(), C.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1 && C.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_TRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)B.data(), B.stride_0(), + beta, + (double*)C.data(), C.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemm:: - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return SerialGemmInternal:: - invoke(C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemm:: + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return SerialGemmInternal:: + invoke(C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); } + } + #endif diff --git a/src/batched/KokkosBatched_Gemm_Serial_Internal.hpp b/src/batched/KokkosBatched_Gemm_Serial_Internal.hpp index df91b2dcfe..afad371334 100644 --- a/src/batched/KokkosBatched_Gemm_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Gemm_Serial_Internal.hpp @@ -11,147 +11,144 @@ #include "KokkosBatched_InnerGemmFixC_Serial_Impl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== + /// + /// Serial Internal Impl + /// ==================== - template - struct SerialGemmInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, const int k, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ B, const int bs0, const int bs1, - const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1); - }; - - template<> + template + struct SerialGemmInternal { template KOKKOS_INLINE_FUNCTION - int - SerialGemmInternal:: + static int invoke(const int m, const int n, const int k, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, const ValueType *__restrict__ B, const int bs0, const int bs1, const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) + /**/ ValueType *__restrict__ C, const int cs0, const int cs1); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemmInternal:: + invoke(const int m, const int n, const int k, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ B, const int bs0, const int bs1, + const ScalarType beta, + /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - if (beta == zero) SerialSetInternal ::invoke(m, n, zero, C, cs0, cs1); - else if (beta != one ) SerialScaleInternal::invoke(m, n, beta, C, cs0, cs1); + if (beta == zero) SerialSetInternal ::invoke(m, n, zero, C, cs0, cs1); + else if (beta != one ) SerialScaleInternal::invoke(m, n, beta, C, cs0, cs1); - if (alpha != zero) { - if (m <= 0 || n <= 0 || k <= 0) return 0; + if (alpha != zero) { + if (m <= 0 || n <= 0 || k <= 0) return 0; - ValueType - *__restrict__ pC = C; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - SerialGemmInternal:: - invoke(const int m, const int n, const int k, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ B, const int bs0, const int bs1, - const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemmInternal:: + invoke(const int m, const int n, const int k, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ B, const int bs0, const int bs1, + const ScalarType beta, + /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) - enum : int { - mbAlgo = Algo::Gemm::Blocked::mb(), - nbAlgo = Algo::Gemm::Blocked::mb() - }; + enum : int { + mbAlgo = Algo::Gemm::Blocked::mb(), + nbAlgo = Algo::Gemm::Blocked::mb() + }; - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - if (beta == zero) SerialSetInternal ::invoke(m, n, zero, C, cs0, cs1); - else if (beta != one ) SerialScaleInternal::invoke(m, n, beta, C, cs0, cs1); + if (beta == zero) SerialSetInternal ::invoke(m, n, zero, C, cs0, cs1); + else if (beta != one ) SerialScaleInternal::invoke(m, n, beta, C, cs0, cs1); - if (alpha != zero) { - if (m <= 0 || n <= 0 || k <= 0) return 0; - const ValueType alpha_value(alpha); + if (alpha != zero) { + if (m <= 0 || n <= 0 || k <= 0) return 0; + const ValueType alpha_value(alpha); - InnerGemmFixC inner(as0, as1, bs0, bs1, cs0, cs1); - auto gemm = [&](const int ib, - const int jb, - const int pb, - const ValueType *__restrict__ AA, - const ValueType *__restrict__ BB, - /**/ ValueType *__restrict__ CC) { - const int mb = mbAlgo, nb = nbAlgo; - for (int i=0;i ib ? (ib-i) : mb, - (j+nb) > jb ? (jb-j) : nb, - pb, - CC+i*cs0+j*cs1); - }; + InnerGemmFixC inner(as0, as1, bs0, bs1, cs0, cs1); + auto gemm = [&](const int ib, + const int jb, + const int pb, + const ValueType *__restrict__ AA, + const ValueType *__restrict__ BB, + /**/ ValueType *__restrict__ CC) { + const int mb = mbAlgo, nb = nbAlgo; + for (int i=0;i ib ? (ib-i) : mb, + (j+nb) > jb ? (jb-j) : nb, + pb, + CC+i*cs0+j*cs1); + }; - const bool is_small = true; //(m*n*k <= 64*64*64); - if (is_small) { - gemm(m, n, k, A, B, C); - } else { - // // cache blocking - // const int - // nc = nb*10, kc = mb*4, mc = mb*4; + const bool is_small = true; //(m*n*k <= 64*64*64); + if (is_small) { + gemm(m, n, k, A, B, C); + } else { + // // cache blocking + // const int + // nc = nb*10, kc = mb*4, mc = mb*4; - // for (int jj=0;jj - struct TeamGemm { + template + struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - template - struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + struct TeamGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - /// - /// T/NT - /// + /// + /// T/NT + /// - template - struct TeamGemm { + template + struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - template - struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + struct TeamGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - /// - /// NT/T - /// + /// + /// NT/T + /// - template - struct TeamGemm { + template + struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - template - struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + struct TeamGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - /// - /// T/T - /// + /// + /// T/T + /// - template - struct TeamGemm { + template + struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - template - struct TeamGemm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B, - const ScalarType beta, - const CViewType &C) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - return TeamGemmInternal:: - invoke(member, - C.extent(0), C.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0(), - beta, - C.data(), C.stride_0(), C.stride_1()); - } - }; + template + struct TeamGemm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B, + const ScalarType beta, + const CViewType &C) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + return TeamGemmInternal:: + invoke(member, + C.extent(0), C.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0(), + beta, + C.data(), C.stride_0(), C.stride_1()); + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Gemm_Team_Internal.hpp b/src/batched/KokkosBatched_Gemm_Team_Internal.hpp index f566610d1e..f4f682cb91 100644 --- a/src/batched/KokkosBatched_Gemm_Team_Internal.hpp +++ b/src/batched/KokkosBatched_Gemm_Team_Internal.hpp @@ -11,171 +11,170 @@ #include "KokkosBatched_InnerGemmFixC_Serial_Impl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Internal Impl - /// ==================== - template - struct TeamGemmInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, const int k, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ B, const int bs0, const int bs1, - const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1); - }; - template<> + /// + /// Team Internal Impl + /// ==================== + template + struct TeamGemmInternal { template KOKKOS_INLINE_FUNCTION - int - TeamGemmInternal:: + static int invoke(const MemberType &member, const int m, const int n, const int k, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, const ValueType *__restrict__ B, const int bs0, const int bs1, const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { - - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) + /**/ ValueType *__restrict__ C, const int cs0, const int cs1); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamGemmInternal:: + invoke(const MemberType &member, + const int m, const int n, const int k, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ B, const int bs0, const int bs1, + const ScalarType beta, + /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { + + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - if (beta == zero) TeamSetInternal ::invoke(member, m, n, zero, C, cs0, cs1); - else if (beta != one ) TeamScaleInternal::invoke(member, m, n, beta, C, cs0, cs1); + if (beta == zero) TeamSetInternal ::invoke(member, m, n, zero, C, cs0, cs1); + else if (beta != one ) TeamScaleInternal::invoke(member, m, n, beta, C, cs0, cs1); - if (alpha != ScalarType(0.0)) { - if (m <= 0 || n <= 0 || k <= 0) return 0; + if (alpha != ScalarType(0.0)) { + if (m <= 0 || n <= 0 || k <= 0) return 0; - if (beta != one) - member.team_barrier(); + if (beta != one) + member.team_barrier(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n),[&](const int &ij) { - // assume layout right for batched computation - const int i = ij/n, j = ij%n; - const ValueType - *__restrict__ pA = A+i*as0, - *__restrict__ pB = B+j*bs1; + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n),[&](const int &ij) { + // assume layout right for batched computation + const int i = ij/n, j = ij%n; + const ValueType + *__restrict__ pA = A+i*as0, + *__restrict__ pB = B+j*bs1; - ValueType c = 0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - TeamGemmInternal:: - invoke(const MemberType &member, - const int m, const int n, const int k, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ B, const int bs0, const int bs1, - const ScalarType beta, - /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { - // C = beta C + alpha A B - // C (m x n), A(m x k), B(k x n) - - enum : int { - mbAlgo = Algo::Gemm::Blocked::mb(), - nbAlgo = Algo::Gemm::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamGemmInternal:: + invoke(const MemberType &member, + const int m, const int n, const int k, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ B, const int bs0, const int bs1, + const ScalarType beta, + /**/ ValueType *__restrict__ C, const int cs0, const int cs1) { + // C = beta C + alpha A B + // C (m x n), A(m x k), B(k x n) + + enum : int { + mbAlgo = Algo::Gemm::Blocked::mb(), + nbAlgo = Algo::Gemm::Blocked::mb() + }; - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - if (beta == zero) TeamSetInternal ::invoke(member, m, n, zero, C, cs0, cs1); - else if (beta != one ) TeamScaleInternal::invoke(member, m, n, beta, C, cs0, cs1); - - if (alpha != ScalarType(0.0)) { - if (m <= 0 || n <= 0 || k <= 0) return 0; - - if (beta != one) - member.team_barrier(); - - /// - /// case cuda: team size is large and blocksize (mb,nb) is small - InnerGemmFixC inner(as0, as1, bs0, bs1, cs0, cs1); - auto gemm = [&](const int ib, - const int jb, - const int pb, - const ValueType *__restrict__ AA, - const ValueType *__restrict__ BB, - /**/ ValueType *__restrict__ CC) { - // Made this non-const in order to WORKAROUND issue #349 - int - mb = mbAlgo, mp = (ib%mb), mq = (ib/mb) + (mp>0), - nb = nbAlgo, np = (jb%nb), nq = (jb/nb) + (np>0); + if (beta == zero) TeamSetInternal ::invoke(member, m, n, zero, C, cs0, cs1); + else if (beta != one ) TeamScaleInternal::invoke(member, m, n, beta, C, cs0, cs1); + + if (alpha != ScalarType(0.0)) { + if (m <= 0 || n <= 0 || k <= 0) return 0; + + if (beta != one) + member.team_barrier(); + + /// + /// case cuda: team size is large and blocksize (mb,nb) is small + InnerGemmFixC inner(as0, as1, bs0, bs1, cs0, cs1); + auto gemm = [&](const int ib, + const int jb, + const int pb, + const ValueType *__restrict__ AA, + const ValueType *__restrict__ BB, + /**/ ValueType *__restrict__ CC) { + // Made this non-const in order to WORKAROUND issue #349 + int + mb = mbAlgo, mp = (ib%mb), mq = (ib/mb) + (mp>0), + nb = nbAlgo, np = (jb%nb), nq = (jb/nb) + (np>0); - // square tiling - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member, mq*nq ), - [&](const int &ij) { + // square tiling + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member, mq*nq ), + [&](const int &ij) { #if \ - defined (KOKKOS_ENABLE_CUDA) && \ + defined (KOKKOS_ENABLE_CUDA) && \ defined (KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA) - const int i = ij%mq*mb, j = ij/mq*nb; + const int i = ij%mq*mb, j = ij/mq*nb; #else - const int i = ij/nq*mb, j = ij%nq*nb; + const int i = ij/nq*mb, j = ij%nq*nb; #endif - inner.serial_invoke(alpha, - AA+i*as0, BB+j*bs1, - (i+mb) > ib ? mp : mb, - (j+nb) > jb ? np : nb, - pb, - CC+i*cs0+j*cs1); - }); - }; + inner.serial_invoke(alpha, + AA+i*as0, BB+j*bs1, + (i+mb) > ib ? mp : mb, + (j+nb) > jb ? np : nb, + pb, + CC+i*cs0+j*cs1); + }); + }; - const bool is_small = true; //(m*n*k <= 64*64*64); - if (is_small) { - gemm(m, n, k, A, B, C); - } else { - // // cache blocking - // const int - // nc = nb*10, kc = mb*4, mc = mb*4; + const bool is_small = true; //(m*n*k <= 64*64*64); + if (is_small) { + gemm(m, n, k, A, B, C); + } else { + // // cache blocking + // const int + // nc = nb*10, kc = mb*4, mc = mb*4; - // for (int jj=0;jj - struct SerialGemv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y); - }; + + /// + /// Serial Gemv + /// + + template + struct SerialGemv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y); + }; - /// - /// Team Gemv - /// - - template - struct TeamGemv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y); - }; - - /// - /// Selective Interface - /// - template - struct Gemv { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialGemv::invoke(alpha, A, x, beta, y); - } else if (std::is_same::value) { - r_val = TeamGemv::invoke(member, alpha, A, x, beta, y); - } - return r_val; - } - }; + /// + /// Team Gemv + /// + + template + struct TeamGemv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y); + }; + + /// + /// Selective Interface + /// + template + struct Gemv { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialGemv::invoke(alpha, A, x, beta, y); + } else if (std::is_same::value) { + r_val = TeamGemv::invoke(member, alpha, A, x, beta, y); + } + return r_val; + } + }; } -} + #define KOKKOSBATCHED_SERIAL_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::SerialGemvInternal \ + KokkosBatched::SerialGemvInternal \ ::invoke(M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) #define KOKKOSBATCHED_SERIAL_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::SerialGemvInternal \ + KokkosBatched::SerialGemvInternal \ ::invoke(N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) #define KOKKOSBATCHED_TEAM_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::TeamGemvInternal \ + KokkosBatched::TeamGemvInternal \ ::invoke(MEMBER, M, N, ALPHA, A, AS0, AS1, X, XS, BETA, Y, YS) #define KOKKOSBATCHED_TEAM_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - KokkosBatched::Experimental::TeamGemvInternal \ + KokkosBatched::TeamGemvInternal \ ::invoke(MEMBER, N, M, ALPHA, A, AS1, AS0, X, XS, BETA, Y, YS) #define KOKKOSBATCHED_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_GEMV_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ } #define KOKKOSBATCHED_GEMV_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_GEMV_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,M,N,ALPHA,A,AS0,AS1,X,XS,BETA,Y,YS); \ } diff --git a/src/batched/KokkosBatched_Gemv_Serial_Impl.hpp b/src/batched/KokkosBatched_Gemv_Serial_Impl.hpp index 876531ecff..edabbb1b93 100644 --- a/src/batched/KokkosBatched_Gemv_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Gemv_Serial_Impl.hpp @@ -8,230 +8,228 @@ #include "KokkosBatched_Gemv_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== - /// CompactMKL does not exist on Gemv + /// + /// Serial Impl + /// =========== + /// CompactMKL does not exist on Gemv - /// - /// Implemented: - /// NT, T - /// - /// Not yet implemented - /// CT + /// + /// Implemented: + /// NT, T + /// + /// Not yet implemented + /// CT - /// - /// NT - /// + /// + /// NT + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - typedef typename yViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = A.dimension(0), - n = 1, - k = A.dimension(1); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)x.data(), x.stride_0(), - beta, - (double*)y.data(), y.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)x.data(), x.stride_0(), - beta, - (double*)y.data(), y.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + typedef typename yViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = A.dimension(0), + n = 1, + k = A.dimension(1); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_NOTRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)x.data(), x.stride_0(), + beta, + (double*)y.data(), y.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_NOTRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)x.data(), x.stride_0(), + beta, + (double*)y.data(), y.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return SerialGemvInternal:: - invoke(A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return SerialGemvInternal:: + invoke(A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return SerialGemvInternal:: - invoke(A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - /// - /// T - /// + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return SerialGemvInternal:: + invoke(A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } + /// + /// T + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - typedef typename yViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; - - const int - m = A.dimension(0), - n = 1, - k = A.dimension(1); - - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_1(), - (const double*)x.data(), x.stride_0(), - beta, - (double*)y.data(), y.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_NOTRANS, - m, n, k, - alpha, - (const double*)A.data(), A.stride_0(), - (const double*)x.data(), x.stride_0(), - beta, - (double*)y.data(), y.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + typedef typename yViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; + + const int + m = A.dimension(0), + n = 1, + k = A.dimension(1); + + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dgemm_compact(MKL_COL_MAJOR, MKL_TRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_1(), + (const double*)x.data(), x.stride_0(), + beta, + (double*)y.data(), y.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dgemm_compact(MKL_ROW_MAJOR, MKL_TRANS, MKL_NOTRANS, + m, n, k, + alpha, + (const double*)A.data(), A.stride_0(), + (const double*)x.data(), x.stride_0(), + beta, + (double*)y.data(), y.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return SerialGemvInternal:: - invoke(A.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return SerialGemvInternal:: + invoke(A.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialGemv:: - invoke(const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return SerialGemvInternal:: - invoke(A.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemv:: + invoke(const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return SerialGemvInternal:: + invoke(A.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); } + } #endif diff --git a/src/batched/KokkosBatched_Gemv_Serial_Internal.hpp b/src/batched/KokkosBatched_Gemv_Serial_Internal.hpp index 74e37b9672..bbcfc9cbac 100644 --- a/src/batched/KokkosBatched_Gemv_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Gemv_Serial_Internal.hpp @@ -11,55 +11,53 @@ #include "KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Internal Impl - /// ==================== - - template - struct SerialGemvInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, - const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0); - }; - template<> + /// + /// Serial Internal Impl + /// ==================== + + template + struct SerialGemvInternal { template KOKKOS_INLINE_FUNCTION - int - SerialGemvInternal:: + static int invoke(const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, + const ValueType *__restrict__ x, const int xs0, const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0) { - - const ScalarType one(1.0), zero(0.0); - - // y = beta y + alpha A x - // y (m), A(m x n), B(n) - - if (beta == zero) SerialSetInternal ::invoke(m, zero, y, ys0); - else if (beta != one) SerialScaleInternal::invoke(m, beta, y, ys0); + /**/ ValueType *__restrict__ y, const int ys0); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemvInternal:: + invoke(const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ x, const int xs0, + const ScalarType beta, + /**/ ValueType *__restrict__ y, const int ys0) { + + const ScalarType one(1.0), zero(0.0); + + // y = beta y + alpha A x + // y (m), A(m x n), B(n) + + if (beta == zero) SerialSetInternal ::invoke(m, zero, y, ys0); + else if (beta != one) SerialScaleInternal::invoke(m, beta, y, ys0); - if (alpha != zero) { - if (m <= 0 || n <= 0) return 0; + if (alpha != zero) { + if (m <= 0 || n <= 0) return 0; - for (int i=0;i - template - KOKKOS_INLINE_FUNCTION - int - SerialGemvInternal:: - invoke(const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, - const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0) { - - const ScalarType one(1.0), zero(0.0); - - // y = beta y + alpha A x - // y (m), A(m x n), B(n) - - enum : int { - mbAlgo = Algo::Gemv::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialGemvInternal:: + invoke(const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ x, const int xs0, + const ScalarType beta, + /**/ ValueType *__restrict__ y, const int ys0) { + + const ScalarType one(1.0), zero(0.0); + + // y = beta y + alpha A x + // y (m), A(m x n), B(n) + + enum : int { + mbAlgo = Algo::Gemv::Blocked::mb() + }; - if (beta == zero) SerialSetInternal ::invoke(m, zero, y, ys0); - else if (beta != one) SerialScaleInternal::invoke(m, beta, y, ys0); + if (beta == zero) SerialSetInternal ::invoke(m, zero, y, ys0); + else if (beta != one) SerialScaleInternal::invoke(m, beta, y, ys0); - if (alpha != zero) { - if (m <= 0 || n <= 0) return 0; + if (alpha != zero) { + if (m <= 0 || n <= 0) return 0; - InnerMultipleDotProduct inner(as0, as1, xs0, ys0); - const int mb = mbAlgo; - for (int i=0;i m ? (m-i) : mb, n, y+i*ys0 ); - } - return 0; + InnerMultipleDotProduct inner(as0, as1, xs0, ys0); + const int mb = mbAlgo; + for (int i=0;i m ? (m-i) : mb, n, y+i*ys0 ); } - + return 0; } + } diff --git a/src/batched/KokkosBatched_Gemv_Team_Impl.hpp b/src/batched/KokkosBatched_Gemv_Team_Impl.hpp index 03204254f8..4fa6c4044c 100644 --- a/src/batched/KokkosBatched_Gemv_Team_Impl.hpp +++ b/src/batched/KokkosBatched_Gemv_Team_Impl.hpp @@ -7,134 +7,132 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Gemv_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Impl - /// ========= + /// + /// Team Impl + /// ========= - /// - /// Implemented: - /// NT, T - /// - /// Not yet implemented - /// CT + /// + /// Implemented: + /// NT, T + /// + /// Not yet implemented + /// CT - /// - /// NT - /// + /// + /// NT + /// - template - struct TeamGemv { + template + struct TeamGemv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return TeamGemvInternal:: - invoke(member, - A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - }; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return TeamGemvInternal:: + invoke(member, + A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } + }; - template - struct TeamGemv { - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return TeamGemvInternal:: - invoke(member, - A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - }; - - /// - /// T - /// - - template - struct TeamGemv { - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return TeamGemvInternal:: - invoke(member, - A.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - }; + template + struct TeamGemv { + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return TeamGemvInternal:: + invoke(member, + A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } + }; + + /// + /// T + /// + + template + struct TeamGemv { + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return TeamGemvInternal:: + invoke(member, + A.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } + }; - template - struct TeamGemv { - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const xViewType &x, - const ScalarType beta, - const yViewType &y) { - return TeamGemvInternal:: - invoke(member, - A.extent(1), A.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - x.data(), x.stride_0(), - beta, - y.data(), y.stride_0()); - } - }; - - } + template + struct TeamGemv { + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const xViewType &x, + const ScalarType beta, + const yViewType &y) { + return TeamGemvInternal:: + invoke(member, + A.extent(1), A.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + x.data(), x.stride_0(), + beta, + y.data(), y.stride_0()); + } + }; + } + #endif diff --git a/src/batched/KokkosBatched_Gemv_Team_Internal.hpp b/src/batched/KokkosBatched_Gemv_Team_Internal.hpp index 0a8673a020..8179f9e86c 100644 --- a/src/batched/KokkosBatched_Gemv_Team_Internal.hpp +++ b/src/batched/KokkosBatched_Gemv_Team_Internal.hpp @@ -11,124 +11,120 @@ #include "KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Internal Impl - /// ==================== - template - struct TeamGemvInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, - const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0); - }; - - template<> + /// + /// Team Internal Impl + /// ==================== + template + struct TeamGemvInternal { template KOKKOS_INLINE_FUNCTION - int - TeamGemvInternal:: + static int invoke(const MemberType &member, const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, + const ValueType *__restrict__ x, const int xs0, const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0) { - const ScalarType one(1.0), zero(0.0); + /**/ ValueType *__restrict__ y, const int ys0); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamGemvInternal:: + invoke(const MemberType &member, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ x, const int xs0, + const ScalarType beta, + /**/ ValueType *__restrict__ y, const int ys0) { + const ScalarType one(1.0), zero(0.0); - // y = beta y + alpha A x - // y (m), A(m x n), B(n) + // y = beta y + alpha A x + // y (m), A(m x n), B(n) - if (beta == zero) TeamSetInternal ::invoke(member, m, zero, y, ys0); - else if (beta != one) TeamScaleInternal::invoke(member, m, beta, y, ys0); + if (beta == zero) TeamSetInternal ::invoke(member, m, zero, y, ys0); + else if (beta != one) TeamScaleInternal::invoke(member, m, beta, y, ys0); - if (alpha != zero) { - if (m <= 0 || n <= 0) return 0; + if (alpha != zero) { + if (m <= 0 || n <= 0) return 0; - if (beta != one) - member.team_barrier(); + if (beta != one) + member.team_barrier(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m),[&](const int &i) { - ValueType t(0); - const ValueType *__restrict__ tA = (A + i*as0); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m),[&](const int &i) { + ValueType t(0); + const ValueType *__restrict__ tA = (A + i*as0); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - TeamGemvInternal:: - invoke(const MemberType &member, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - const ValueType *__restrict__ x, const int xs0, - const ScalarType beta, - /**/ ValueType *__restrict__ y, const int ys0) { + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamGemvInternal:: + invoke(const MemberType &member, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + const ValueType *__restrict__ x, const int xs0, + const ScalarType beta, + /**/ ValueType *__restrict__ y, const int ys0) { - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - // y = beta y + alpha A x - // y (m), A(m x n), B(n) + // y = beta y + alpha A x + // y (m), A(m x n), B(n) - enum : int { - mbAlgo = Algo::Gemv::Blocked::mb() - }; + enum : int { + mbAlgo = Algo::Gemv::Blocked::mb() + }; - if (beta == zero) TeamSetInternal ::invoke(member, m, zero, y, ys0); - else if (beta != one) TeamScaleInternal::invoke(member, m, beta, y, ys0); + if (beta == zero) TeamSetInternal ::invoke(member, m, zero, y, ys0); + else if (beta != one) TeamScaleInternal::invoke(member, m, beta, y, ys0); - if (alpha != zero) { - if (m <= 0 || n <= 0) return 0; + if (alpha != zero) { + if (m <= 0 || n <= 0) return 0; - if (beta != one) - member.team_barrier(); + if (beta != one) + member.team_barrier(); - InnerMultipleDotProduct inner(as0, as1, xs0, ys0); - const int tsize = member.team_size(); - const int mb_a = m/tsize + (m%tsize>0), mb_b = mbAlgo; - // Made this non-const in order to WORKAROUND issue #349 - int mb = mb_a < mb_b ? mb_a : mb_b, mp = m%mb; + InnerMultipleDotProduct inner(as0, as1, xs0, ys0); + const int tsize = member.team_size(); + const int mb_a = m/tsize + (m%tsize>0), mb_b = mbAlgo; + // Made this non-const in order to WORKAROUND issue #349 + int mb = mb_a < mb_b ? mb_a : mb_b, mp = m%mb; - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member, (m/mb) + (mp>0)), - [&](const int &ii) { - const int i = ii*mb; - inner.serial_invoke(alpha, A+i*as0, x, (i+mb) > m ? (m-i) : mb, n, y+i*ys0 ); - }); - member.team_barrier(); - } - - return 0; + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member, (m/mb) + (mp>0)), + [&](const int &ii) { + const int i = ii*mb; + inner.serial_invoke(alpha, A+i*as0, x, (i+mb) > m ? (m-i) : mb, n, y+i*ys0 ); + }); + member.team_barrier(); } + + return 0; } -} - +} #endif diff --git a/src/batched/KokkosBatched_Givens_Serial_Internal.hpp b/src/batched/KokkosBatched_Givens_Serial_Internal.hpp index ebc6515caf..e8e425bf5c 100644 --- a/src/batched/KokkosBatched_Givens_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Givens_Serial_Internal.hpp @@ -6,64 +6,62 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialGivensInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ValueType chi1, - const ValueType chi2, - /* */ Kokkos::pair * G, - /* */ ValueType * chi1_new) { - typedef ValueType value_type; - const value_type zero(0), one(1); - /// compute G = [ gamma -sigma; - /// sigma gamma ]; - /// G.first = gamma and G.second = sigma - /// this rotation satisfy the following - /// G' [chi1; = [ alpha; - /// chi2] zero ]; - value_type cs, sn, r; - if (chi2 == zero) { - r = chi1; - cs = one; - sn = zero; - } else if (chi1 == zero) { - r = chi2; - cs = zero; - sn = one; - } else { - // here we do not care overflow caused by the division although it is probable.... - r = Kokkos::Details::ArithTraits::sqrt(chi1*chi1 + chi2*chi2); - cs = chi1/r; - sn = chi2/r; - if (Kokkos::Details::ArithTraits::abs(chi1) > - Kokkos::Details::ArithTraits::abs(chi2) && cs < zero) { - cs = -cs; - sn = -sn; - r = -r; - } + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ValueType chi1, + const ValueType chi2, + /* */ Kokkos::pair * G, + /* */ ValueType * chi1_new) { + typedef ValueType value_type; + const value_type zero(0), one(1); + /// compute G = [ gamma -sigma; + /// sigma gamma ]; + /// G.first = gamma and G.second = sigma + /// this rotation satisfy the following + /// G' [chi1; = [ alpha; + /// chi2] zero ]; + value_type cs, sn, r; + if (chi2 == zero) { + r = chi1; + cs = one; + sn = zero; + } else if (chi1 == zero) { + r = chi2; + cs = zero; + sn = one; + } else { + // here we do not care overflow caused by the division although it is probable.... + r = Kokkos::Details::ArithTraits::sqrt(chi1*chi1 + chi2*chi2); + cs = chi1/r; + sn = chi2/r; + if (Kokkos::Details::ArithTraits::abs(chi1) > + Kokkos::Details::ArithTraits::abs(chi2) && cs < zero) { + cs = -cs; + sn = -sn; + r = -r; } - G->first = cs; - G->second = sn; - *chi1_new = r; - - return 0; } - }; - }// end namespace Experimental + G->first = cs; + G->second = sn; + *chi1_new = r; + + return 0; + } + }; + } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp index dc52f03486..5ee839e275 100644 --- a/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergFormQ_Serial_Internal.hpp @@ -10,49 +10,48 @@ #include "KokkosBatched_ApplyQ_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialHessenbergFormQInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int k, - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * Q, const int qs0, const int qs1, - /* */ ValueType * w, - const bool is_Q_zero = false) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialHessenbergFormQInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * Q, const int qs0, const int qs1, + /* */ ValueType * w, + const bool is_Q_zero = false) { + typedef ValueType value_type; - /// Given a matrix A that includes Hessenberg factorization - /// it forms a unitary matrix Q - /// B = Q = (H0 H1 H2 H3 ... H(k-2)) I - /// where - /// A is m x k (holding H0, H1 ... H(k-2) - /// t is k x 1 - /// B is m x m - // set identity - if (is_Q_zero) - SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); - else - SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + /// Given a matrix A that includes Hessenberg factorization + /// it forms a unitary matrix Q + /// B = Q = (H0 H1 H2 H3 ... H(k-2)) I + /// where + /// A is m x k (holding H0, H1 ... H(k-2) + /// t is k x 1 + /// B is m x m + // set identity + if (is_Q_zero) + SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); + else + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); - return SerialApplyQ_LeftNoTransForwardInternal - ::invoke(m-1, m-1, k-1, - A+as0, as0, as1, - t, ts, - Q+qs0+qs1, qs1, qs0, - w); - } - }; - - }// end namespace Experimental + return SerialApplyQ_LeftNoTransForwardInternal + ::invoke(m-1, m-1, k-1, + A+as0, as0, as1, + t, ts, + Q+qs0+qs1, qs1, qs0, + w); + } + }; + } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp index a96661febf..c889a06f0b 100644 --- a/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_HessenbergQR_WithShift_Serial_Internal.hpp @@ -9,130 +9,129 @@ #include "KokkosBatched_ApplyGivens_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialHessenbergQR_WithShiftInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int mbeg, const int mend, const int morg, - /* */ ValueType * HH, const int hs0, const int hs1, - const ValueType shift, - /* */ Kokkos::pair * GG, const bool request_schur) { - typedef ValueType value_type; - //typedef Kokkos::Details::ArithTraits ats; - - const int hs = hs0+hs1; - const value_type zero(0), one(1); - const Kokkos::pair identity(one,zero); - - /// redefine variables - const int m = mend-mbeg, mbeg_mult_hs0 = mbeg*hs0; - value_type *H = HH+mbeg*hs; - - /// initialize Gs - Kokkos::pair *Gs = NULL; - if (request_schur) { - for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const ValueType shift, + /* */ Kokkos::pair * GG, const bool request_schur) { + typedef ValueType value_type; + //typedef Kokkos::Details::ArithTraits ats; + + const int hs = hs0+hs1; + const value_type zero(0), one(1); + const Kokkos::pair identity(one,zero); + + /// redefine variables + const int m = mend-mbeg, mbeg_mult_hs0 = mbeg*hs0; + value_type *H = HH+mbeg*hs; + + /// initialize Gs + Kokkos::pair *Gs = NULL; + if (request_schur) { + for (int i=0;i G; - - /// 0. compute the first givens rotation that introduces a bulge - { - const value_type chi1 = H[0] - shift; - const value_type chi2 = H[hs0]; - /* */ value_type alpha; - SerialGivensInternal::invoke(chi1, chi2, - &G, - &alpha); - // record G - if (request_schur) Gs[0] = G; - - value_type *h11 = H; - value_type *h21 = H + hs0; - value_type *h12 = H + hs1; - - // apply G' from left - G.second = -G.second; // transpose G - const int nn = m; - SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), - h11, hs1, - h21, hs1); - - // apply (G')' from right - const int mm = m < 3 ? m : 3; - SerialApplyRightGivensInternal::invoke(G, mm+mbeg, - h11-mbeg_mult_hs0, hs0, - h12-mbeg_mult_hs0, hs0); - } - - /// 1. chase the bulge - - // partitions used for loop iteration - Partition2x2 H_part2x2(hs0, hs1); - Partition3x3 H_part3x3(hs0, hs1); - - // initial partition of A where ATL has a zero dimension - H_part2x2.partWithATL(H, m, m, 1, 1); - - for (int m_htl=1;m_htl<(m-1);++m_htl) { - // part 2x2 into 3x3 - H_part3x3.partWithABR(H_part2x2, 1, 1); - //const int n_hbr = m - m_htl; - /// ----------------------------------------------------- - value_type *chi1 = H_part3x3.A11-hs1; - value_type *chi2 = H_part3x3.A21-hs1; - SerialGivensInternal::invoke(*chi1, *chi2, - &G, - chi1); *chi2 = zero; - // record G - if (request_schur) Gs[m_htl] = G; + /// Given a strict Hessenberg matrix H (m x m), + /// it computes a single implicit QR step with a given shift + /// - it assumes H has zeros on subdiagonal entries ( + /// givens rotation is defined as G = [gamma -sigma + /// sigma gamma] + /// G' [chi1 chi2]^t = [alpha 0]^T + /// where G is stored as a pair of gamma and sigma + Kokkos::pair G; + + /// 0. compute the first givens rotation that introduces a bulge + { + const value_type chi1 = H[0] - shift; + const value_type chi2 = H[hs0]; + /* */ value_type alpha; + SerialGivensInternal::invoke(chi1, chi2, + &G, + &alpha); + // record G + if (request_schur) Gs[0] = G; + + value_type *h11 = H; + value_type *h21 = H + hs0; + value_type *h12 = H + hs1; + + // apply G' from left + G.second = -G.second; // transpose G + const int nn = m; + SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), + h11, hs1, + h21, hs1); - G.second = -G.second; // transpose G - - const int nn = m - m_htl; - SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), - H_part3x3.A11, hs1, - H_part3x3.A21, hs1); - - const int mtmp = m_htl+3, mm = mtmp < m ? mtmp : m; - SerialApplyRightGivensInternal::invoke(G, mm+mbeg, - H_part3x3.A01-mbeg_mult_hs0, hs0, - H_part3x3.A02-mbeg_mult_hs0, hs0); - /// ----------------------------------------------------- - H_part2x2.mergeToATL(H_part3x3); - } - return 0; + // apply (G')' from right + const int mm = m < 3 ? m : 3; + SerialApplyRightGivensInternal::invoke(G, mm+mbeg, + h11-mbeg_mult_hs0, hs0, + h12-mbeg_mult_hs0, hs0); } - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const int mbeg, const int mend, const int morg, - /* */ ValueType * HH, const int hs0, const int hs1, - const ValueType shift) { - return invoke(mbeg, mend, morg, - HH, hs0, hs1, shift, - (Kokkos::pair*)NULL, false); - + /// 1. chase the bulge + + // partitions used for loop iteration + Partition2x2 H_part2x2(hs0, hs1); + Partition3x3 H_part3x3(hs0, hs1); + + // initial partition of A where ATL has a zero dimension + H_part2x2.partWithATL(H, m, m, 1, 1); + + for (int m_htl=1;m_htl<(m-1);++m_htl) { + // part 2x2 into 3x3 + H_part3x3.partWithABR(H_part2x2, 1, 1); + //const int n_hbr = m - m_htl; + /// ----------------------------------------------------- + value_type *chi1 = H_part3x3.A11-hs1; + value_type *chi2 = H_part3x3.A21-hs1; + SerialGivensInternal::invoke(*chi1, *chi2, + &G, + chi1); *chi2 = zero; + // record G + if (request_schur) Gs[m_htl] = G; + + G.second = -G.second; // transpose G + + const int nn = m - m_htl; + SerialApplyLeftGivensInternal::invoke (G, nn+(morg-mend), + H_part3x3.A11, hs1, + H_part3x3.A21, hs1); + + const int mtmp = m_htl+3, mm = mtmp < m ? mtmp : m; + SerialApplyRightGivensInternal::invoke(G, mm+mbeg, + H_part3x3.A01-mbeg_mult_hs0, hs0, + H_part3x3.A02-mbeg_mult_hs0, hs0); + /// ----------------------------------------------------- + H_part2x2.mergeToATL(H_part3x3); } - }; + return 0; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const int mbeg, const int mend, const int morg, + /* */ ValueType * HH, const int hs0, const int hs1, + const ValueType shift) { + return invoke(mbeg, mend, morg, + HH, hs0, hs1, shift, + (Kokkos::pair*)NULL, false); + + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp index 5bd6b0cd13..967e44b077 100644 --- a/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Hessenberg_Serial_Internal.hpp @@ -9,98 +9,97 @@ #include "KokkosBatched_ApplyHouseholder_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialHessenbergInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, // m = NumRows(A) - const int n, // n = NumCols(A) - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * w) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialHessenbergInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(A) + const int n, // n = NumCols(A) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * w) { + typedef ValueType value_type; - /// Given a matrix A, it computes hessenberg decomposition of the matrix - /// - t is to store tau and w is for workspace - /// - H = Q^H A Q and A = Q H Q^H + /// Given a matrix A, it computes hessenberg decomposition of the matrix + /// - t is to store tau and w is for workspace + /// - H = Q^H A Q and A = Q H Q^H - // partitions used for loop iteration - Partition2x2 A_part2x2(as0, as1); - Partition3x3 A_part3x3(as0, as1); + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); - Partition2x1 t_part2x1(ts); - Partition3x1 t_part3x1(ts); + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); - // partitions used in loop body - Partition2x1 A21_part2x1(as0); - Partition2x1 A22_part2x1(as0); - Partition1x2 A2_part1x2 (as1); + // partitions used in loop body + Partition2x1 A21_part2x1(as0); + Partition2x1 A22_part2x1(as0); + Partition1x2 A2_part1x2 (as1); - // initial partition of A where ATL has a zero dimension - A_part2x2.partWithATL(A, m, n, 0, 0); - t_part2x1.partWithAT (t, m, 0 ); + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, m, n, 0, 0); + t_part2x1.partWithAT (t, m, 0 ); - for (int m_atl=0;m_atl 0) { - // partition A21 into 2x1 - A21_part2x1.partWithAT(A_part3x3.A21, m_A22, 1); + /// ----------------------------------------------------- + if (m_A22 > 0) { + // partition A21 into 2x1 + A21_part2x1.partWithAT(A_part3x3.A21, m_A22, 1); - // perform householder transformation - const int m_A22_b = m_A22 - 1; - SerialLeftHouseholderInternal::invoke(m_A22_b, - A21_part2x1.AT, - A21_part2x1.AB, as0, - tau); + // perform householder transformation + const int m_A22_b = m_A22 - 1; + SerialLeftHouseholderInternal::invoke(m_A22_b, + A21_part2x1.AT, + A21_part2x1.AB, as0, + tau); - // partition A22 into 2x1 - A22_part2x1.partWithAT(A_part3x3.A22, m_A22, 1); + // partition A22 into 2x1 + A22_part2x1.partWithAT(A_part3x3.A22, m_A22, 1); - // left apply householder to partitioned A22 - SerialApplyLeftHouseholderInternal::invoke(m_A22_b, n_A22, - tau, - A21_part2x1.AB, as0, - A22_part2x1.AT, as1, - A22_part2x1.AB, as0, as1, - w); + // left apply householder to partitioned A22 + SerialApplyLeftHouseholderInternal::invoke(m_A22_b, n_A22, + tau, + A21_part2x1.AB, as0, + A22_part2x1.AT, as1, + A22_part2x1.AB, as0, as1, + w); - // partition A*2 column into 1x2 - A2_part1x2.partWithAL(A_part3x3.A02, n_A22, 1); + // partition A*2 column into 1x2 + A2_part1x2.partWithAL(A_part3x3.A02, n_A22, 1); - // right apply householder to A*2 colums - const int n_A22_r = n_A22 - 1; - SerialApplyRightHouseholderInternal::invoke(m, n_A22_r, - tau, - A21_part2x1.AB, as0, - A2_part1x2.AL, as0, - A2_part1x2.AR, as0, as1, - w); - } - /// ----------------------------------------------------- - A_part2x2.mergeToATL(A_part3x3); - t_part2x1.mergeToAT (t_part3x1); + // right apply householder to A*2 colums + const int n_A22_r = n_A22 - 1; + SerialApplyRightHouseholderInternal::invoke(m, n_A22_r, + tau, + A21_part2x1.AB, as0, + A2_part1x2.AL, as0, + A2_part1x2.AR, as0, as1, + w); } - return 0; + /// ----------------------------------------------------- + A_part2x2.mergeToATL(A_part3x3); + t_part2x1.mergeToAT (t_part3x1); } - }; + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Householder_Decl.hpp b/src/batched/KokkosBatched_Householder_Decl.hpp index dc06dd2e77..6624cb3ac4 100644 --- a/src/batched/KokkosBatched_Householder_Decl.hpp +++ b/src/batched/KokkosBatched_Householder_Decl.hpp @@ -7,25 +7,23 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Householder - /// - - // level 1 operation (no blocking algorithm info avail) - template - struct SerialHouseholder { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const aViewType &a, - const tauViewType &tau); - }; - - } + + /// + /// Serial Householder + /// + + // level 1 operation (no blocking algorithm info avail) + template + struct SerialHouseholder { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const aViewType &a, + const tauViewType &tau); + }; + } #endif diff --git a/src/batched/KokkosBatched_Householder_Serial_Impl.hpp b/src/batched/KokkosBatched_Householder_Serial_Impl.hpp index ebc5da5393..e837526353 100644 --- a/src/batched/KokkosBatched_Householder_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Householder_Serial_Impl.hpp @@ -7,30 +7,27 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Householder_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Impl - /// =========== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialHouseholder:: - invoke(const aViewType &a, - const tauViewType &tau) { - return SerialLeftHouseholderInternal:: - invoke(a.extent(0)-1, - a.data(), - a.data()+a.stride(0), a.stride(0), - tau.data()); - } - + + /// + /// Serial Impl + /// =========== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialHouseholder:: + invoke(const aViewType &a, + const tauViewType &tau) { + return SerialLeftHouseholderInternal:: + invoke(a.extent(0)-1, + a.data(), + a.data()+a.stride(0), a.stride(0), + tau.data()); } + } diff --git a/src/batched/KokkosBatched_Householder_Serial_Internal.hpp b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp index 208cfaaa45..cecca70b9c 100644 --- a/src/batched/KokkosBatched_Householder_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Householder_Serial_Internal.hpp @@ -6,76 +6,74 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialLeftHouseholderInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m_x2, - /* */ ValueType * chi1, - /* */ ValueType * x2, const int x2s, - /* */ ValueType * tau) { - typedef ValueType value_type; - typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialLeftHouseholderInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m_x2, + /* */ ValueType * chi1, + /* */ ValueType * x2, const int x2s, + /* */ ValueType * tau) { + typedef ValueType value_type; + typedef typename Kokkos::Details::ArithTraits::mag_type mag_type; - const mag_type zero(0); - const mag_type half(0.5); - const mag_type one(1); - const mag_type minus_one(-1); - - /// compute the 2norm of x2 - mag_type norm_x2_square(0); - for (int i=0;i::abs(*chi1); + /// compute magnitude of chi1, equal to norm2 of chi1 + const mag_type norm_chi1 = Kokkos::Details::ArithTraits::abs(*chi1); - /// compute 2 norm of x using norm_chi1 and norm_x2 - const mag_type norm_x = Kokkos::Details::ArithTraits::sqrt(norm_x2_square + norm_chi1*norm_chi1); + /// compute 2 norm of x using norm_chi1 and norm_x2 + const mag_type norm_x = Kokkos::Details::ArithTraits::sqrt(norm_x2_square + norm_chi1*norm_chi1); - /// compute alpha - const mag_type alpha = (*chi1 < 0 ? one : minus_one)*norm_x; + /// compute alpha + const mag_type alpha = (*chi1 < 0 ? one : minus_one)*norm_x; - /// overwrite x2 with u2 - const value_type chi1_minus_alpha = *chi1 - alpha; - const value_type inv_chi1_minus_alpha = one/chi1_minus_alpha; - for (int i=0;i - struct InnerGemmFixA { - const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; + template + struct InnerGemmFixA { + const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; - KOKKOS_INLINE_FUNCTION - InnerGemmFixA(const int as0, const int as1, - const int bs0, const int bs1, - const int cs0, const int cs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1), - _cs0(cs0), _cs1(cs1) {} + KOKKOS_INLINE_FUNCTION + InnerGemmFixA(const int as0, const int as1, + const int bs0, const int bs1, + const int cs0, const int cs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1), + _cs0(cs0), _cs1(cs1) {} - // serial rank update - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C); + // serial rank update + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C); - // serial rank update for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C); - }; - } + // serial rank update for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C); + }; } diff --git a/src/batched/KokkosBatched_InnerGemmFixA_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerGemmFixA_Serial_Impl.hpp index 3af76374d1..fcb7d77db0 100644 --- a/src/batched/KokkosBatched_InnerGemmFixA_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerGemmFixA_Serial_Impl.hpp @@ -7,1284 +7,1282 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerGemmFixA_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Inner kernel (5x5) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1], a_44 = A[4*_as0+4*_as1]; + + /// + /// Inner kernel (5x5) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1], a_44 = A[4*_as0+4*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p, c_3p, - b_4p, c_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p, c_3p, + b_4p, c_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; - - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p, c_3p, - /**/ c_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p, c_3p, + /**/ c_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; - - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - /**/ c_3p, - /**/ c_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + /**/ c_3p, + /**/ c_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - /**/ c_2p, - /**/ c_3p, - /**/ c_4p; - - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; + ValueType + b_0p, c_0p, + b_1p, c_1p, + /**/ c_2p, + /**/ c_3p, + /**/ c_4p; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], - a_30 = A[3*_as0+0*_as1], - a_40 = A[4*_as0+0*_as1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], + a_30 = A[3*_as0+0*_as1], + a_40 = A[4*_as0+0*_as1]; - ValueType - b_0p, c_0p, - /**/ c_1p, - /**/ c_2p, - /**/ c_3p, - /**/ c_4p; + ValueType + b_0p, c_0p, + /**/ c_1p, + /**/ c_2p, + /**/ c_3p, + /**/ c_4p; - const int - ib0 = 0*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; + const int + ib0 = 0*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0, ic4 = 4*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p, c_3p, - b_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p, c_3p, + b_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p, - b_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p, + b_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, - b_3p, - b_4p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, + b_3p, + b_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<1,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<1,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1]; - ValueType - b_0p, c_0p, - b_1p, - b_2p, - b_3p, - b_4p; + ValueType + b_0p, c_0p, + b_1p, + b_2p, + b_3p, + b_4p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, - ic0 = 0*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, ib4 = 4*_bs0, + ic0 = 0*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (m*10+k) { - case 54: { InnerGemmFixA<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 53: { InnerGemmFixA<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 52: { InnerGemmFixA<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 51: { InnerGemmFixA<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 45: { InnerGemmFixA<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 35: { InnerGemmFixA<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 25: { InnerGemmFixA<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 15: { InnerGemmFixA<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - default: { - if (m < 5 && n < 5) { - InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); - for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); - } else { - Kokkos::abort("InnerGemmFixA<5,5>::serial_invoke, assert failure (m<5 && n<5)"); - } - break; - } + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (m*10+k) { + case 54: { InnerGemmFixA<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 53: { InnerGemmFixA<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 52: { InnerGemmFixA<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 51: { InnerGemmFixA<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 45: { InnerGemmFixA<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 35: { InnerGemmFixA<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 25: { InnerGemmFixA<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 15: { InnerGemmFixA<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + default: { + if (m < 5 && n < 5) { + InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); + for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); + } else { + Kokkos::abort("InnerGemmFixA<5,5>::serial_invoke, assert failure (m<5 && n<5)"); } - - return 0; + break; } + } + + return 0; + } - /// - /// Inner kernel (4x4) - /// ================== + /// + /// Inner kernel (4x4) + /// ================== - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p, c_3p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p, c_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - /**/ c_3p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + /**/ c_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - /**/ c_2p, - /**/ c_3p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + /**/ c_2p, + /**/ c_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], - a_30 = A[3*_as0+0*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], + a_30 = A[3*_as0+0*_as1]; - ValueType - b_0p, c_0p, - /**/ c_1p, - /**/ c_2p, - /**/ c_3p; + ValueType + b_0p, c_0p, + /**/ c_1p, + /**/ c_2p, + /**/ c_3p; - const int - ib0 = 0*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; + const int + ib0 = 0*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0, ic3 = 3*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p, - b_3p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p, + b_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, - b_3p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, + b_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<1,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<1,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1]; - ValueType - b_0p, c_0p, - b_1p, - b_2p, - b_3p; + ValueType + b_0p, c_0p, + b_1p, + b_2p, + b_3p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, - ic0 = 0*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, ib3 = 3*_bs0, + ic0 = 0*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (m*10+k) { - case 44: { InnerGemmFixA<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 43: { InnerGemmFixA<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 42: { InnerGemmFixA<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 41: { InnerGemmFixA<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 34: { InnerGemmFixA<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 24: { InnerGemmFixA<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 14: { InnerGemmFixA<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - default: { - if (m < 4 && n < 4) { - InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); - for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); - } else { - Kokkos::abort("InnerGemmFixA<4,4>::serial_invoke, assert failure (m<4 && n<4)"); - } - break; - } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (m*10+k) { + case 44: { InnerGemmFixA<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 43: { InnerGemmFixA<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 42: { InnerGemmFixA<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 41: { InnerGemmFixA<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 34: { InnerGemmFixA<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 24: { InnerGemmFixA<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 14: { InnerGemmFixA<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + default: { + if (m < 4 && n < 4) { + InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); + for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); + } else { + Kokkos::abort("InnerGemmFixA<4,4>::serial_invoke, assert failure (m<4 && n<4)"); + } + break; + } } - /// - /// Inner kernel (3x3) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1]; + return 0; + } + + /// + /// Inner kernel (3x3) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p, c_2p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p, c_2p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - /**/ c_2p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + /**/ c_2p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1]; - ValueType - b_0p, c_0p, - /**/ c_1p, - /**/ c_2p; + ValueType + b_0p, c_0p, + /**/ c_1p, + /**/ c_2p; - const int - ib0 = 0*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; + const int + ib0 = 0*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0, ic2 = 2*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p, - b_2p; + ValueType + b_0p, c_0p, + b_1p, c_1p, + b_2p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<1,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<1,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1]; - ValueType - b_0p, c_0p, - b_1p, - b_2p; + ValueType + b_0p, c_0p, + b_1p, + b_2p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, - ic0 = 0*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, ib2 = 2*_bs0, + ic0 = 0*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (m*10+k) { - case 33: { InnerGemmFixA<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 32: { InnerGemmFixA<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 31: { InnerGemmFixA<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 23: { InnerGemmFixA<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 13: { InnerGemmFixA<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - default: { - if (m < 3 && n < 3) { - InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); - for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); - } else { - Kokkos::abort("InnerGemmFixA<3,3>::serial_invoke, assert failure (m<3 && n<3)"); - } - break; - } + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (m*10+k) { + case 33: { InnerGemmFixA<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 32: { InnerGemmFixA<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 31: { InnerGemmFixA<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 23: { InnerGemmFixA<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 13: { InnerGemmFixA<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + default: { + if (m < 3 && n < 3) { + InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); + for (int i=0;i m ? 1 : 2), n, (p+2 > k ? 1 : 2), C+i*_cs0); + } else { + Kokkos::abort("InnerGemmFixA<3,3>::serial_invoke, assert failure (m<3 && n<3)"); } - - return 0; + break; } + } + + return 0; + } - /// - /// Inner kernel (2x2) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1]; + /// + /// Inner kernel (2x2) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1]; - ValueType - b_0p, c_0p, - b_1p, c_1p; + ValueType + b_0p, c_0p, + b_1p, c_1p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], - a_10 = A[1*_as0+0*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], + a_10 = A[1*_as0+0*_as1]; - ValueType - b_0p, c_0p, - /**/ c_1p; + ValueType + b_0p, c_0p, + /**/ c_1p; - const int - ib0 = 0*_bs0, - ic0 = 0*_cs0, ic1 = 1*_cs0; + const int + ib0 = 0*_bs0, + ic0 = 0*_cs0, ic1 = 1*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<1,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<1,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1]; - ValueType - b_0p, c_0p, - b_1p; + ValueType + b_0p, c_0p, + b_1p; - const int - ib0 = 0*_bs0, ib1 = 1*_bs0, - ic0 = 0*_cs0; + const int + ib0 = 0*_bs0, ib1 = 1*_bs0, + ic0 = 0*_cs0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (m*10+k) { - case 22: { InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 21: { InnerGemmFixA<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 12: { InnerGemmFixA<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - case 11: { InnerGemmFixA<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } - default: { - Kokkos::abort("InnerGemmFixA<2,2>::serial_invoke, assert failure (m<2 && n<2)"); - break; - } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (m*10+k) { + case 22: { InnerGemmFixA<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 21: { InnerGemmFixA<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 12: { InnerGemmFixA<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + case 11: { InnerGemmFixA<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, n, C); break; } + default: { + Kokkos::abort("InnerGemmFixA<2,2>::serial_invoke, assert failure (m<2 && n<2)"); + break; + } } - /// - /// Inner kernel (1x1) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixA<1,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C) { - if (n <= 0) return 0; - - const ValueType - a_00 = A[0*_as0+0*_as1]; + return 0; + } + + /// + /// Inner kernel (1x1) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixA<1,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C) { + if (n <= 0) return 0; + + const ValueType + a_00 = A[0*_as0+0*_as1]; - ValueType - b_0p, c_0p; + ValueType + b_0p, c_0p; - const int - ib0 = 0*_bs0, - ic0 = 0*_cs0; + const int + ib0 = 0*_bs0, + ic0 = 0*_cs0; - for (int p=0;p - struct InnerGemmFixB { - const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; + + template + struct InnerGemmFixB { + const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; - KOKKOS_INLINE_FUNCTION - InnerGemmFixA(const int as0, const int as1, - const int bs0, const int bs1, - const int cs0, const int cs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1), - _cs0(cs0), _cs1(cs1) {} + KOKKOS_INLINE_FUNCTION + InnerGemmFixA(const int as0, const int as1, + const int bs0, const int bs1, + const int cs0, const int cs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1), + _cs0(cs0), _cs1(cs1) {} - // serial rank update - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int n, - /**/ ValueType *__restrict__ C); + // serial rank update + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int n, + /**/ ValueType *__restrict__ C); - // serial rank update for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C); - }; - } + // serial rank update for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C); + }; } + #endif diff --git a/src/batched/KokkosBatched_InnerGemmFixB_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerGemmFixB_Serial_Impl.hpp index e0e3ff372f..e7f8b1b009 100644 --- a/src/batched/KokkosBatched_InnerGemmFixB_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerGemmFixB_Serial_Impl.hpp @@ -7,1140 +7,1138 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerGemmFixB_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Inner kernel (5x5) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], b_34 = B[3*_bs0+4*_bs1], - b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1], b_43 = B[4*_bs0+3*_bs1], b_44 = B[4*_bs0+4*_bs1]; + + /// + /// Inner kernel (5x5) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], b_34 = B[3*_bs0+4*_bs1], + b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1], b_43 = B[4*_bs0+3*_bs1], b_44 = B[4*_bs0+4*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, a_p4, - c_p0, c_p1, c_p2, c_p3, c_p4; + ValueType + a_p0, a_p1, a_p2, a_p3, a_p4, + c_p0, c_p1, c_p2, c_p3, c_p4; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], - b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1], b_43 = B[4*_bs0+3*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], + b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1], b_43 = B[4*_bs0+3*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, a_p4, - c_p0, c_p1, c_p2, c_p3; + ValueType + a_p0, a_p1, a_p2, a_p3, a_p4, + c_p0, c_p1, c_p2, c_p3; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], - b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], + b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1], b_42 = B[4*_bs0+2*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, a_p4, - c_p0, c_p1, c_p2; + ValueType + a_p0, a_p1, a_p2, a_p3, a_p4, + c_p0, c_p1, c_p2; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], - b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], + b_40 = B[4*_bs0+0*_bs1], b_41 = B[4*_bs0+1*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, a_p4, - c_p0, c_p1; + ValueType + a_p0, a_p1, a_p2, a_p3, a_p4, + c_p0, c_p1; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], - b_10 = B[1*_bs0+0*_bs1], - b_20 = B[2*_bs0+0*_bs1], - b_30 = B[3*_bs0+0*_bs1], - b_40 = B[4*_bs0+0*_bs1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], + b_10 = B[1*_bs0+0*_bs1], + b_20 = B[2*_bs0+0*_bs1], + b_30 = B[3*_bs0+0*_bs1], + b_40 = B[4*_bs0+0*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, a_p4, - c_p0; + ValueType + a_p0, a_p1, a_p2, a_p3, a_p4, + c_p0; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, ja4 = 4*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], b_34 = B[3*_bs0+4*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1], b_34 = B[3*_bs0+4*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, - c_p0, c_p1, c_p2, c_p3, c_p4; + ValueType + a_p0, a_p1, a_p2, a_p3, + c_p0, c_p1, c_p2, c_p3, c_p4; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], b_24 = B[2*_bs0+4*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0, c_p1, c_p2, c_p3, c_p4; + ValueType + a_p0, a_p1, a_p2, + c_p0, c_p1, c_p2, c_p3, c_p4; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], b_14 = B[1*_bs0+4*_bs1]; - ValueType - a_p0, a_p1, - c_p0, c_p1, c_p2, c_p3, c_p4; + ValueType + a_p0, a_p1, + c_p0, c_p1, c_p2, c_p3, c_p4; - const int - ja0 = 0*_as1, ja1 = 1*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<1,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<1,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], b_04 = B[0*_bs0+4*_bs1]; - ValueType - a_p0, - c_p0, c_p1, c_p2, c_p3, c_p4; + ValueType + a_p0, + c_p0, c_p1, c_p2, c_p3, c_p4; - const int - ja0 = 0*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; + const int + ja0 = 0*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1, jc4 = 4*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (k*10+n) { - case 54: { InnerGemmFixB<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 53: { InnerGemmFixB<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 52: { InnerGemmFixB<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 51: { InnerGemmFixB<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 45: { InnerGemmFixB<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 35: { InnerGemmFixB<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 25: { InnerGemmFixB<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 15: { InnerGemmFixB<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (k*10+n) { + case 54: { InnerGemmFixB<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 53: { InnerGemmFixB<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 52: { InnerGemmFixB<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 51: { InnerGemmFixB<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 45: { InnerGemmFixB<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 35: { InnerGemmFixB<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 25: { InnerGemmFixB<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 15: { InnerGemmFixB<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } } - /// - /// Inner kernel (4x4) - /// ================== + return 0; + } + + /// + /// Inner kernel (4x4) + /// ================== - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1], b_33 = B[3*_bs0+3*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, - c_p0, c_p1, c_p2, c_p3; + ValueType + a_p0, a_p1, a_p2, a_p3, + c_p0, c_p1, c_p2, c_p3; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1], b_32 = B[3*_bs0+2*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, - c_p0, c_p1, c_p2; + ValueType + a_p0, a_p1, a_p2, a_p3, + c_p0, c_p1, c_p2; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], - b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], + b_30 = B[3*_bs0+0*_bs1], b_31 = B[3*_bs0+1*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, - c_p0, c_p1; + ValueType + a_p0, a_p1, a_p2, a_p3, + c_p0, c_p1; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], - b_10 = B[1*_bs0+0*_bs1], - b_20 = B[2*_bs0+0*_bs1], - b_30 = B[3*_bs0+0*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], + b_10 = B[1*_bs0+0*_bs1], + b_20 = B[2*_bs0+0*_bs1], + b_30 = B[3*_bs0+0*_bs1]; - ValueType - a_p0, a_p1, a_p2, a_p3, - c_p0; + ValueType + a_p0, a_p1, a_p2, a_p3, + c_p0; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, ja3 = 3*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1], b_23 = B[2*_bs0+3*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0, c_p1, c_p2, c_p3; + ValueType + a_p0, a_p1, a_p2, + c_p0, c_p1, c_p2, c_p3; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], b_13 = B[1*_bs0+3*_bs1]; - ValueType - a_p0, a_p1, - c_p0, c_p1, c_p2, c_p3; + ValueType + a_p0, a_p1, + c_p0, c_p1, c_p2, c_p3; - const int - ja0 = 0*_as1, ja1 = 1*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<1,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<1,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], b_03 = B[0*_bs0+3*_bs1]; - ValueType - a_p0, - c_p0, c_p1, c_p2, c_p3; + ValueType + a_p0, + c_p0, c_p1, c_p2, c_p3; - const int - ja0 = 0*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; + const int + ja0 = 0*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1, jc3 = 3*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (k*10+n) { - case 43: { InnerGemmFixB<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 42: { InnerGemmFixB<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 41: { InnerGemmFixB<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 34: { InnerGemmFixB<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 24: { InnerGemmFixB<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 14: { InnerGemmFixB<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (k*10+n) { + case 43: { InnerGemmFixB<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 42: { InnerGemmFixB<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 41: { InnerGemmFixB<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 34: { InnerGemmFixB<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 24: { InnerGemmFixB<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 14: { InnerGemmFixB<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } } - /// - /// Inner kernel (3x3) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1]; + return 0; + } + + /// + /// Inner kernel (3x3) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1], b_22 = B[2*_bs0+2*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0, c_p1, c_p2; + ValueType + a_p0, a_p1, a_p2, + c_p0, c_p1, c_p2; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1, jc2 = 2*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], - b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], + b_20 = B[2*_bs0+0*_bs1], b_21 = B[2*_bs0+1*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0, c_p1; + ValueType + a_p0, a_p1, a_p2, + c_p0, c_p1; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], - b_10 = B[1*_bs0+0*_bs1], - b_20 = B[2*_bs0+0*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], + b_10 = B[1*_bs0+0*_bs1], + b_20 = B[2*_bs0+0*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0; + ValueType + a_p0, a_p1, a_p2, + c_p0; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], b_02 = B[0*_bs0+2*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1], b_12 = B[1*_bs0+2*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0, c_p1; + ValueType + a_p0, a_p1, a_p2, + c_p0, c_p1; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<1,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1]; + + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<1,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1]; - ValueType - a_p0, a_p1, a_p2, - c_p0; + ValueType + a_p0, a_p1, a_p2, + c_p0; - const int - ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, ja2 = 2*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (k*10+n) { - case 32: { InnerGemmFixB<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 31: { InnerGemmFixB<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 23: { InnerGemmFixB<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 13: { InnerGemmFixB<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (k*10+n) { + case 32: { InnerGemmFixB<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 31: { InnerGemmFixB<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 23: { InnerGemmFixB<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 13: { InnerGemmFixB<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } } - /// - /// Inner kernel (2x2) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], - b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1]; + return 0; + } + + /// + /// Inner kernel (2x2) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1], + b_10 = B[1*_bs0+0*_bs1], b_11 = B[1*_bs0+1*_bs1]; - ValueType - a_p0, a_p1, - c_p0, c_p1; + ValueType + a_p0, a_p1, + c_p0, c_p1; - const int - ja0 = 0*_as1, ja1 = 1*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], - b_10 = B[1*_bs0+0*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], + b_10 = B[1*_bs0+0*_bs1]; - ValueType - a_p0, a_p1, - c_p0; + ValueType + a_p0, a_p1, + c_p0; - const int - ja0 = 0*_as1, ja1 = 1*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, ja1 = 1*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<1,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<1,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1], b_01 = B[0*_bs0+1*_bs1]; - ValueType - a_p0, - c_p0, c_p1; + ValueType + a_p0, + c_p0, c_p1; - const int - ja0 = 0*_as1, - jc0 = 0*_cs1, jc1 = 1*_cs1; + const int + ja0 = 0*_as1, + jc0 = 0*_cs1, jc1 = 1*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - switch (k*10+n) { - case 21: { InnerGemmFixB<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 12: { InnerGemmFixB<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - } + return 0; + } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + switch (k*10+n) { + case 21: { InnerGemmFixB<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 12: { InnerGemmFixB<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } } - /// - /// Inner kernel (1x1) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<1,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, - /**/ ValueType *__restrict__ C) { - if (m <= 0) return 0; - - const ValueType - b_00 = B[0*_bs0+0*_bs1]; + return 0; + } + + /// + /// Inner kernel (1x1) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<1,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, + /**/ ValueType *__restrict__ C) { + if (m <= 0) return 0; + + const ValueType + b_00 = B[0*_bs0+0*_bs1]; - ValueType - a_p0, - c_p0; + ValueType + a_p0, + c_p0; - const int - ja0 = 0*_as1, - jc0 = 0*_cs1; + const int + ja0 = 0*_as1, + jc0 = 0*_cs1; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixB<0,0>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - - if (k == n) { - switch (k) { - case 5: { InnerGemmFixB<5,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 4: { InnerGemmFixB<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 3: { InnerGemmFixB<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 2: { InnerGemmFixB<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - case 1: { InnerGemmFixB<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } - } - } else { - for (int i=0;i + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixB<0,0>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + + if (k == n) { + switch (k) { + case 5: { InnerGemmFixB<5,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 4: { InnerGemmFixB<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 3: { InnerGemmFixB<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 2: { InnerGemmFixB<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + case 1: { InnerGemmFixB<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, C); break; } + } + } else { + for (int i=0;i - struct InnerGemmFixC { - const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; - - KOKKOS_INLINE_FUNCTION - InnerGemmFixC(const int as0, const int as1, - const int bs0, const int bs1, - const int cs0, const int cs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1), - _cs0(cs0), _cs1(cs1) {} + template + struct InnerGemmFixC { + const int _as0, _as1, _bs0, _bs1, _cs0, _cs1; - // serial rank update - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C); - - // serial rank update for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int k, - /**/ ValueType *__restrict__ C); + KOKKOS_INLINE_FUNCTION + InnerGemmFixC(const int as0, const int as1, + const int bs0, const int bs1, + const int cs0, const int cs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1), + _cs0(cs0), _cs1(cs1) {} - // serial rank update for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C); - - template - KOKKOS_INLINE_FUNCTION - int team_invoke(const MemberType &member, - const ScalarType alpha, + // serial rank update + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, const ValueType *__restrict__ A, const ValueType *__restrict__ B, const int k, /**/ ValueType *__restrict__ C); + + // serial rank update for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int k, + /**/ ValueType *__restrict__ C); - // team rank update for remainder - template - KOKKOS_INLINE_FUNCTION - int team_invoke(const MemberType &member, - const ScalarType alpha, + // serial rank update for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ScalarType alpha, const ValueType *__restrict__ A, const ValueType *__restrict__ B, const int m, const int n, const int k, /**/ ValueType *__restrict__ C); - }; - } + + template + KOKKOS_INLINE_FUNCTION + int team_invoke(const MemberType &member, + const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C); + + // team rank update for remainder + template + KOKKOS_INLINE_FUNCTION + int team_invoke(const MemberType &member, + const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C); + }; } diff --git a/src/batched/KokkosBatched_InnerGemmFixC_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerGemmFixC_Serial_Impl.hpp index 8b8cf6ca4b..11174eafb6 100644 --- a/src/batched/KokkosBatched_InnerGemmFixC_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerGemmFixC_Serial_Impl.hpp @@ -7,1306 +7,1304 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerGemmFixC_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Inner kernel (5x5) - /// ================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, - a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, c_34 = 0, - a_4p, b_p4, c_40 = 0, c_41 = 0, c_42 = 0, c_43 = 0, c_44 = 0; + + /// + /// Inner kernel (5x5) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, + a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, c_34 = 0, + a_4p, b_p4, c_40 = 0, c_41 = 0, c_42 = 0, c_43 = 0, c_44 = 0; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, - a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, - a_4p, c_40 = 0, c_41 = 0, c_42 = 0, c_43 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, + a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, + a_4p, c_40 = 0, c_41 = 0, c_42 = 0, c_43 = 0; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, - a_3p, c_30 = 0, c_31 = 0, c_32 = 0, - a_4p, c_40 = 0, c_41 = 0, c_42 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, + a_3p, c_30 = 0, c_31 = 0, c_32 = 0, + a_4p, c_40 = 0, c_41 = 0, c_42 = 0; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, - a_2p, c_20 = 0, c_21 = 0, - a_3p, c_30 = 0, c_31 = 0, - a_4p, c_40 = 0, c_41 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, + a_2p, c_20 = 0, c_21 = 0, + a_3p, c_30 = 0, c_31 = 0, + a_4p, c_40 = 0, c_41 = 0; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, - j0 = 0*_bs1, j1 = 1*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, + j0 = 0*_bs1, j1 = 1*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, - a_1p, c_10 = 0, - a_2p, c_20 = 0, - a_3p, c_30 = 0, - a_4p, c_40 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, + a_1p, c_10 = 0, + a_2p, c_20 = 0, + a_3p, c_30 = 0, + a_4p, c_40 = 0; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, - j0 = 0*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0, + j0 = 0*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, - a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, c_34 = 0, - /**/ b_p4; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, + a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0, c_34 = 0, + /**/ b_p4; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, - /**/ b_p3, - /**/ b_p4; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_24 = 0, + /**/ b_p3, + /**/ b_p4; - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, - /**/ b_p2, - /**/ b_p3, - /**/ b_p4; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, c_14 = 0, + /**/ b_p2, + /**/ b_p3, + /**/ b_p4; - const int - i0 = 0*_as0, i1 = 1*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; + const int + i0 = 0*_as0, i1 = 1*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, - /**/ b_p1, - /**/ b_p2, - /**/ b_p3, - /**/ b_p4; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_04 = 0, + /**/ b_p1, + /**/ b_p2, + /**/ b_p3, + /**/ b_p4; - const int - i0 = 0*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; + const int + i0 = 0*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1, j4 = 4*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, - a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, + a_3p, b_p3, c_30 = 0, c_31 = 0, c_32 = 0, c_33 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, - a_3p, c_30 = 0, c_31 = 0, c_32 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; + C[0*_cs0+0*_cs1] += alpha * c_00; C[0*_cs0+1*_cs1] += alpha * c_01; C[0*_cs0+2*_cs1] += alpha * c_02; C[0*_cs0+3*_cs1] += alpha * c_03; + C[1*_cs0+0*_cs1] += alpha * c_10; C[1*_cs0+1*_cs1] += alpha * c_11; C[1*_cs0+2*_cs1] += alpha * c_12; C[1*_cs0+3*_cs1] += alpha * c_13; + C[2*_cs0+0*_cs1] += alpha * c_20; C[2*_cs0+1*_cs1] += alpha * c_21; C[2*_cs0+2*_cs1] += alpha * c_22; C[2*_cs0+3*_cs1] += alpha * c_23; + C[3*_cs0+0*_cs1] += alpha * c_30; C[3*_cs0+1*_cs1] += alpha * c_31; C[3*_cs0+2*_cs1] += alpha * c_32; C[3*_cs0+3*_cs1] += alpha * c_33; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, + a_3p, c_30 = 0, c_31 = 0, c_32 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, - a_2p, c_20 = 0, c_21 = 0, - a_3p, c_30 = 0, c_31 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, - j0 = 0*_bs1, j1 = 1*_bs1; + C[0*_cs0+0*_cs1] += alpha * c_00; C[0*_cs0+1*_cs1] += alpha * c_01; C[0*_cs0+2*_cs1] += alpha * c_02; + C[1*_cs0+0*_cs1] += alpha * c_10; C[1*_cs0+1*_cs1] += alpha * c_11; C[1*_cs0+2*_cs1] += alpha * c_12; + C[2*_cs0+0*_cs1] += alpha * c_20; C[2*_cs0+1*_cs1] += alpha * c_21; C[2*_cs0+2*_cs1] += alpha * c_22; + C[3*_cs0+0*_cs1] += alpha * c_30; C[3*_cs0+1*_cs1] += alpha * c_31; C[3*_cs0+2*_cs1] += alpha * c_32; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, + a_2p, c_20 = 0, c_21 = 0, + a_3p, c_30 = 0, c_31 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, + j0 = 0*_bs1, j1 = 1*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, - a_1p, c_10 = 0, - a_2p, c_20 = 0, - a_3p, c_30 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, - j0 = 0*_bs1; + C[0*_cs0+0*_cs1] += alpha * c_00; C[0*_cs0+1*_cs1] += alpha * c_01; + C[1*_cs0+0*_cs1] += alpha * c_10; C[1*_cs0+1*_cs1] += alpha * c_11; + C[2*_cs0+0*_cs1] += alpha * c_20; C[2*_cs0+1*_cs1] += alpha * c_21; + C[3*_cs0+0*_cs1] += alpha * c_30; C[3*_cs0+1*_cs1] += alpha * c_31; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, + a_1p, c_10 = 0, + a_2p, c_20 = 0, + a_3p, c_30 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, + j0 = 0*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, - /**/ b_p3; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; + C[0*_cs0+0*_cs1] += alpha * c_00; + C[1*_cs0+0*_cs1] += alpha * c_10; + C[2*_cs0+0*_cs1] += alpha * c_20; + C[3*_cs0+0*_cs1] += alpha * c_30; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, + /**/ b_p3; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, - /**/ b_p2, - /**/ b_p3; - - const int - i0 = 0*_as0, i1 = 1*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; + C[0*_cs0+0*_cs1] += alpha * c_00; C[0*_cs0+1*_cs1] += alpha * c_01; C[0*_cs0+2*_cs1] += alpha * c_02; C[0*_cs0+3*_cs1] += alpha * c_03; + C[1*_cs0+0*_cs1] += alpha * c_10; C[1*_cs0+1*_cs1] += alpha * c_11; C[1*_cs0+2*_cs1] += alpha * c_12; C[1*_cs0+3*_cs1] += alpha * c_13; + C[2*_cs0+0*_cs1] += alpha * c_20; C[2*_cs0+1*_cs1] += alpha * c_21; C[2*_cs0+2*_cs1] += alpha * c_22; C[2*_cs0+3*_cs1] += alpha * c_23; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, c_13 = 0, + /**/ b_p2, + /**/ b_p3; + + const int + i0 = 0*_as0, i1 = 1*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, - /**/ b_p1, - /**/ b_p2, - /**/ b_p3; - - const int - i0 = 0*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, + /**/ b_p1, + /**/ b_p2, + /**/ b_p3; + + const int + i0 = 0*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1, j3 = 3*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, - a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; + /// + /// Inner kernel (3x3) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, + a_2p, b_p2, c_20 = 0, c_21 = 0, c_22 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, - a_2p, c_20 = 0, c_21 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, - j0 = 0*_bs1, j1 = 1*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, + a_2p, c_20 = 0, c_21 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, + j0 = 0*_bs1, j1 = 1*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, - a_1p, c_10 = 0, - a_2p, c_20 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, - j0 = 0*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, + a_1p, c_10 = 0, + a_2p, c_20 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, + j0 = 0*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, - /**/ b_p2; - - const int - i0 = 0*_as0, i1 = 1*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0, c_12 = 0, + /**/ b_p2; + + const int + i0 = 0*_as0, i1 = 1*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, - /**/ b_p1, - /**/ b_p2; - - const int - i0 = 0*_as0, - j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, c_02 = 0, + /**/ b_p1, + /**/ b_p2; + + const int + i0 = 0*_as0, + j0 = 0*_bs1, j1 = 1*_bs1, j2 = 2*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, - a_1p, b_p1, c_10 = 0, c_11 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, - j0 = 0*_bs1, j1 = 1*_bs1; + /// + /// Inner kernel (2x2) + /// ================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, + a_1p, b_p1, c_10 = 0, c_11 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, + j0 = 0*_bs1, j1 = 1*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, - a_1p, c_10 = 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, - j0 = 0*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, + a_1p, c_10 = 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, + j0 = 0*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; - - ValueType - a_0p, b_p0, c_00 = 0, c_01 = 0, - /**/ b_p1; - const int - i0 = 0*_as0, - j0 = 0*_bs1, j1 = 1*_bs1; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; + + ValueType + a_0p, b_p0, c_00 = 0, c_01 = 0, + /**/ b_p1; + const int + i0 = 0*_as0, + j0 = 0*_bs1, j1 = 1*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - if (k <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + if (k <= 0) return 0; - ValueType - a_0p, b_p0, c_00 = 0; + ValueType + a_0p, b_p0, c_00 = 0; - const int - i0 = 0*_as0, - j0 = 0*_bs1; + const int + i0 = 0*_as0, + j0 = 0*_bs1; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<0,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int k, - /**/ ValueType *__restrict__ C) { - if (m <= 0 || k <= 0) return 0; - - switch (m) { - case 5: { InnerGemmFixC<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 4: { InnerGemmFixC<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 3: { InnerGemmFixC<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 2: { InnerGemmFixC<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 1: { InnerGemmFixC<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - default: { - Kokkos::abort("InnerGemmFixC<0,1>::serial_invoke, assert failure (m<=5)"); - break; - } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<0,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int k, + /**/ ValueType *__restrict__ C) { + if (m <= 0 || k <= 0) return 0; + + switch (m) { + case 5: { InnerGemmFixC<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 4: { InnerGemmFixC<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 3: { InnerGemmFixC<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 2: { InnerGemmFixC<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 1: { InnerGemmFixC<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + default: { + Kokkos::abort("InnerGemmFixC<0,1>::serial_invoke, assert failure (m<=5)"); + break; + } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<5,5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - if (!(m<=5 && n<=5)) - Kokkos::abort("InnerGemmFixC<5,5>::serial_invoke, assert failure (m<=5 && n<=5)"); - - switch (m*10+n) { - case 55: { InnerGemmFixC<5,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 54: { InnerGemmFixC<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 53: { InnerGemmFixC<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 52: { InnerGemmFixC<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 51: { InnerGemmFixC<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 45: { InnerGemmFixC<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 35: { InnerGemmFixC<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 25: { InnerGemmFixC<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 15: { InnerGemmFixC<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - default: { - InnerGemmFixC<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); - break; - } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<5,5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + if (!(m<=5 && n<=5)) + Kokkos::abort("InnerGemmFixC<5,5>::serial_invoke, assert failure (m<=5 && n<=5)"); + + switch (m*10+n) { + case 55: { InnerGemmFixC<5,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 54: { InnerGemmFixC<5,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 53: { InnerGemmFixC<5,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 52: { InnerGemmFixC<5,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 51: { InnerGemmFixC<5,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 45: { InnerGemmFixC<4,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 35: { InnerGemmFixC<3,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 25: { InnerGemmFixC<2,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 15: { InnerGemmFixC<1,5> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + default: { + InnerGemmFixC<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); + break; } + } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<4,4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - if (!(m<=4 && n<=4)) - Kokkos::abort("InnerGemmFixC<4,4>::serial_invoke, assert failure (m<=4 && n<=4)"); - - switch (m*10+n) { - case 44: { InnerGemmFixC<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 43: { InnerGemmFixC<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 42: { InnerGemmFixC<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 41: { InnerGemmFixC<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 34: { InnerGemmFixC<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 24: { InnerGemmFixC<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 14: { InnerGemmFixC<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - default: { - InnerGemmFixC<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); - break; - } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<4,4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + if (!(m<=4 && n<=4)) + Kokkos::abort("InnerGemmFixC<4,4>::serial_invoke, assert failure (m<=4 && n<=4)"); + + switch (m*10+n) { + case 44: { InnerGemmFixC<4,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 43: { InnerGemmFixC<4,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 42: { InnerGemmFixC<4,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 41: { InnerGemmFixC<4,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 34: { InnerGemmFixC<3,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 24: { InnerGemmFixC<2,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 14: { InnerGemmFixC<1,4> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + default: { + InnerGemmFixC<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); + break; } - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<3,3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - if (!(m<=3 && n<=3)) - Kokkos::abort("InnerGemmFixC<3,3>::serial_invoke, assert failure (m<=3 && n<=3)"); - - switch (m*10+n) { - case 33: { InnerGemmFixC<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 32: { InnerGemmFixC<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 31: { InnerGemmFixC<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 23: { InnerGemmFixC<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 13: { InnerGemmFixC<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - default: { - InnerGemmFixC<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); - break; - } - } - return 0; } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<2,2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - if (!(m<=2 && n<=2)) - Kokkos::abort("InnerGemmFixC<2,2>::serial_invoke, assert failure (m<=2 && n<=2)"); - - switch (m*10+n) { - case 22: { InnerGemmFixC<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 21: { InnerGemmFixC<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 12: { InnerGemmFixC<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - case 11: { InnerGemmFixC<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<3,3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + if (!(m<=3 && n<=3)) + Kokkos::abort("InnerGemmFixC<3,3>::serial_invoke, assert failure (m<=3 && n<=3)"); + + switch (m*10+n) { + case 33: { InnerGemmFixC<3,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 32: { InnerGemmFixC<3,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 31: { InnerGemmFixC<3,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 23: { InnerGemmFixC<2,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 13: { InnerGemmFixC<1,3> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + default: { + InnerGemmFixC<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, m, n, k, C); + break; } + } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC<1,1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - if (m <=0 || n <= 0 || k <= 0) return 0; - if (!(m<=1 && n<=1)) - Kokkos::abort("InnerGemmFixC<1,1>::serial_invoke, assert failure (m<=1 && n<=1)"); - - return serial_invoke(alpha, A, B, k, C);; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<2,2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + if (!(m<=2 && n<=2)) + Kokkos::abort("InnerGemmFixC<2,2>::serial_invoke, assert failure (m<=2 && n<=2)"); + + switch (m*10+n) { + case 22: { InnerGemmFixC<2,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 21: { InnerGemmFixC<2,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 12: { InnerGemmFixC<1,2> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } + case 11: { InnerGemmFixC<1,1> inner(_as0, _as1, _bs0, _bs1, _cs0, _cs1); inner.serial_invoke(alpha, A, B, k, C); break; } } + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC<1,1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + if (m <=0 || n <= 0 || k <= 0) return 0; + if (!(m<=1 && n<=1)) + Kokkos::abort("InnerGemmFixC<1,1>::serial_invoke, assert failure (m<=1 && n<=1)"); + + return serial_invoke(alpha, A, B, k, C);; } + } + #endif diff --git a/src/batched/KokkosBatched_InnerGemmFixC_Team_Impl.hpp b/src/batched/KokkosBatched_InnerGemmFixC_Team_Impl.hpp index 4dbde38f14..5c136cd24f 100644 --- a/src/batched/KokkosBatched_InnerGemmFixC_Team_Impl.hpp +++ b/src/batched/KokkosBatched_InnerGemmFixC_Team_Impl.hpp @@ -7,70 +7,68 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerGemmFixC_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - template - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC:: - team_invoke(const MemberType &member, - const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int k, - /**/ ValueType *__restrict__ C) { - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,mb*nb),[&](const int &ij) { - const int - i = ij/nb, - j = ij%nb; + template + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC:: + team_invoke(const MemberType &member, + const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int k, + /**/ ValueType *__restrict__ C) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,mb*nb),[&](const int &ij) { + const int + i = ij/nb, + j = ij%nb; - const ValueType - *__restrict__ pA = A+i*_as0, - *__restrict__ pB = B+j*_bs1; + const ValueType + *__restrict__ pA = A+i*_as0, + *__restrict__ pB = B+j*_bs1; - ValueType c = 0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerGemmFixC:: - team_invoke(const MemberType &member, - const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ B, - const int m, const int n, const int k, - /**/ ValueType *__restrict__ C) { - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n),[&](const int &ij) { - const int - i = ij/n, - j = ij%n; + template + template + KOKKOS_INLINE_FUNCTION + int + InnerGemmFixC:: + team_invoke(const MemberType &member, + const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ B, + const int m, const int n, const int k, + /**/ ValueType *__restrict__ C) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n),[&](const int &ij) { + const int + i = ij/n, + j = ij%n; - const ValueType - *__restrict__ pA = A+i*_as0, - *__restrict__ pB = B+j*_bs1; + const ValueType + *__restrict__ pA = A+i*_as0, + *__restrict__ pB = B+j*_bs1; - ValueType c = 0; - for (int p=0;p - struct InnerLU { - const int _as0, _as1; + + template + struct InnerLU { + const int _as0, _as1; - KOKKOS_INLINE_FUNCTION - InnerLU(const int as0, const int as1) - : _as0(as0), _as1(as1) {} + KOKKOS_INLINE_FUNCTION + InnerLU(const int as0, const int as1) + : _as0(as0), _as1(as1) {} - // lu - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(ValueType *__restrict__ A); + // lu + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(ValueType *__restrict__ A); - // for remainder square - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const int m, - ValueType *__restrict__ A); + // for remainder square + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const int m, + ValueType *__restrict__ A); - // for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const int m, const int n, - ValueType *__restrict__ A); - }; - } + // for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const int m, const int n, + ValueType *__restrict__ A); + }; } + #endif diff --git a/src/batched/KokkosBatched_InnerLU_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerLU_Serial_Impl.hpp index fb9163ce1d..4733980525 100644 --- a/src/batched/KokkosBatched_InnerLU_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerLU_Serial_Impl.hpp @@ -7,271 +7,270 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerLU_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Fixed size LU - /// ================ - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<5>:: - serial_invoke(ValueType *__restrict__ A) { - // load - ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1], a_44 = A[4*_as0+4*_as1]; + /// + /// Fixed size LU + /// ================ + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<5>:: + serial_invoke(ValueType *__restrict__ A) { + // load + ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1], a_34 = A[3*_as0+4*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1], a_44 = A[4*_as0+4*_as1]; - // 0 iteration - a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; a_13 -= a_10*a_03; a_14 -= a_10*a_04; - a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; a_23 -= a_20*a_03; a_24 -= a_20*a_04; - a_30 /= a_00; a_31 -= a_30*a_01; a_32 -= a_30*a_02; a_33 -= a_30*a_03; a_34 -= a_30*a_04; - a_40 /= a_00; a_41 -= a_40*a_01; a_42 -= a_40*a_02; a_43 -= a_40*a_03; a_44 -= a_40*a_04; + // 0 iteration + a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; a_13 -= a_10*a_03; a_14 -= a_10*a_04; + a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; a_23 -= a_20*a_03; a_24 -= a_20*a_04; + a_30 /= a_00; a_31 -= a_30*a_01; a_32 -= a_30*a_02; a_33 -= a_30*a_03; a_34 -= a_30*a_04; + a_40 /= a_00; a_41 -= a_40*a_01; a_42 -= a_40*a_02; a_43 -= a_40*a_03; a_44 -= a_40*a_04; - // 1 iteration - a_21 /= a_11; a_22 -= a_21*a_12; a_23 -= a_21*a_13; a_24 -= a_21*a_14; - a_31 /= a_11; a_32 -= a_31*a_12; a_33 -= a_31*a_13; a_34 -= a_31*a_14; - a_41 /= a_11; a_42 -= a_41*a_12; a_43 -= a_41*a_13; a_44 -= a_41*a_14; + // 1 iteration + a_21 /= a_11; a_22 -= a_21*a_12; a_23 -= a_21*a_13; a_24 -= a_21*a_14; + a_31 /= a_11; a_32 -= a_31*a_12; a_33 -= a_31*a_13; a_34 -= a_31*a_14; + a_41 /= a_11; a_42 -= a_41*a_12; a_43 -= a_41*a_13; a_44 -= a_41*a_14; - // 2 iteration - a_32 /= a_22; a_33 -= a_32*a_23; a_34 -= a_32*a_24; - a_42 /= a_22; a_43 -= a_42*a_23; a_44 -= a_42*a_24; + // 2 iteration + a_32 /= a_22; a_33 -= a_32*a_23; a_34 -= a_32*a_24; + a_42 /= a_22; a_43 -= a_42*a_23; a_44 -= a_42*a_24; - // 3 iteration - a_43 /= a_33; a_44 -= a_43*a_34; + // 3 iteration + a_43 /= a_33; a_44 -= a_43*a_34; - // store - A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; A[1*_as0+3*_as1] = a_13; A[1*_as0+4*_as1] = a_14; - A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; A[2*_as0+3*_as1] = a_23; A[2*_as0+4*_as1] = a_24; - A[3*_as0+0*_as1] = a_30; A[3*_as0+1*_as1] = a_31; A[3*_as0+2*_as1] = a_32; A[3*_as0+3*_as1] = a_33; A[3*_as0+4*_as1] = a_34; - A[4*_as0+0*_as1] = a_40; A[4*_as0+1*_as1] = a_41; A[4*_as0+2*_as1] = a_42; A[4*_as0+3*_as1] = a_43; A[4*_as0+4*_as1] = a_44; + // store + A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; A[1*_as0+3*_as1] = a_13; A[1*_as0+4*_as1] = a_14; + A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; A[2*_as0+3*_as1] = a_23; A[2*_as0+4*_as1] = a_24; + A[3*_as0+0*_as1] = a_30; A[3*_as0+1*_as1] = a_31; A[3*_as0+2*_as1] = a_32; A[3*_as0+3*_as1] = a_33; A[3*_as0+4*_as1] = a_34; + A[4*_as0+0*_as1] = a_40; A[4*_as0+1*_as1] = a_41; A[4*_as0+2*_as1] = a_42; A[4*_as0+3*_as1] = a_43; A[4*_as0+4*_as1] = a_44; - return 0; - } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<4>:: - serial_invoke(ValueType *__restrict__ A) { - // load - ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<4>:: + serial_invoke(ValueType *__restrict__ A) { + // load + ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1], a_23 = A[2*_as0+3*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], a_33 = A[3*_as0+3*_as1]; - // 0 iteration - a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; a_13 -= a_10*a_03; - a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; a_23 -= a_20*a_03; - a_30 /= a_00; a_31 -= a_30*a_01; a_32 -= a_30*a_02; a_33 -= a_30*a_03; + // 0 iteration + a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; a_13 -= a_10*a_03; + a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; a_23 -= a_20*a_03; + a_30 /= a_00; a_31 -= a_30*a_01; a_32 -= a_30*a_02; a_33 -= a_30*a_03; - // 1 iteration - a_21 /= a_11; a_22 -= a_21*a_12; a_23 -= a_21*a_13; - a_31 /= a_11; a_32 -= a_31*a_12; a_33 -= a_31*a_13; + // 1 iteration + a_21 /= a_11; a_22 -= a_21*a_12; a_23 -= a_21*a_13; + a_31 /= a_11; a_32 -= a_31*a_12; a_33 -= a_31*a_13; - // 2 iteration - a_32 /= a_22; a_33 -= a_32*a_23; + // 2 iteration + a_32 /= a_22; a_33 -= a_32*a_23; - // store - A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; A[1*_as0+3*_as1] = a_13; - A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; A[2*_as0+3*_as1] = a_23; - A[3*_as0+0*_as1] = a_30; A[3*_as0+1*_as1] = a_31; A[3*_as0+2*_as1] = a_32; A[3*_as0+3*_as1] = a_33; + // store + A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; A[1*_as0+3*_as1] = a_13; + A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; A[2*_as0+3*_as1] = a_23; + A[3*_as0+0*_as1] = a_30; A[3*_as0+1*_as1] = a_31; A[3*_as0+2*_as1] = a_32; A[3*_as0+3*_as1] = a_33; - return 0; - } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<3>:: - serial_invoke(ValueType *__restrict__ A) { - // load - ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<3>:: + serial_invoke(ValueType *__restrict__ A) { + // load + ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1], a_12 = A[1*_as0+2*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], a_22 = A[2*_as0+2*_as1]; - // 0 iteration - a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; - a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; + // 0 iteration + a_10 /= a_00; a_11 -= a_10*a_01; a_12 -= a_10*a_02; + a_20 /= a_00; a_21 -= a_20*a_01; a_22 -= a_20*a_02; - // 1 iteration - a_21 /= a_11; a_22 -= a_21*a_12; + // 1 iteration + a_21 /= a_11; a_22 -= a_21*a_12; - // store - A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; - A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; + // store + A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; A[1*_as0+2*_as1] = a_12; + A[2*_as0+0*_as1] = a_20; A[2*_as0+1*_as1] = a_21; A[2*_as0+2*_as1] = a_22; - return 0; - } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<2>:: - serial_invoke(ValueType *__restrict__ A) { - // load - ValueType - a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], - a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<2>:: + serial_invoke(ValueType *__restrict__ A) { + // load + ValueType + a_00 = A[0*_as0+0*_as1], a_01 = A[0*_as0+1*_as1], + a_10 = A[1*_as0+0*_as1], a_11 = A[1*_as0+1*_as1]; - // 0 iteration - a_10 /= a_00; a_11 -= a_10*a_01; + // 0 iteration + a_10 /= a_00; a_11 -= a_10*a_01; - // store - A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; + // store + A[1*_as0+0*_as1] = a_10; A[1*_as0+1*_as1] = a_11; - return 0; - } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<1>:: - serial_invoke(ValueType *__restrict__ A) { - return 0; - } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<1>:: + serial_invoke(ValueType *__restrict__ A) { + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<5>:: - serial_invoke(const int m, - ValueType *__restrict__ A) { - if (m > 5) - Kokkos::abort("InnerLU<5>::serial_invoke, assert failure (m<=5)"); - if (m <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<5>:: + serial_invoke(const int m, + ValueType *__restrict__ A) { + if (m > 5) + Kokkos::abort("InnerLU<5>::serial_invoke, assert failure (m<=5)"); + if (m <= 0) return 0; - switch (m) { - case 5: { InnerLU<5> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 4: { InnerLU<4> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } - } - return 0; + switch (m) { + case 5: { InnerLU<5> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 4: { InnerLU<4> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<4>:: - serial_invoke(const int m, - ValueType *__restrict__ A) { - if (m > 4) - Kokkos::abort("InnerLU<4>::serial_invoke, assert failure (m<=4)"); - if (m <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<4>:: + serial_invoke(const int m, + ValueType *__restrict__ A) { + if (m > 4) + Kokkos::abort("InnerLU<4>::serial_invoke, assert failure (m<=4)"); + if (m <= 0) return 0; - switch (m) { - case 4: { InnerLU<4> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } - } - return 0; + switch (m) { + case 4: { InnerLU<4> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<3>:: - serial_invoke(const int m, - ValueType *__restrict__ A) { - if (m > 3) - Kokkos::abort("InnerLU<3>::serial_invoke, assert failure (m<=3)"); - if (m <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<3>:: + serial_invoke(const int m, + ValueType *__restrict__ A) { + if (m > 3) + Kokkos::abort("InnerLU<3>::serial_invoke, assert failure (m<=3)"); + if (m <= 0) return 0; - switch (m) { - case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } - } - return 0; + switch (m) { + case 3: { InnerLU<3> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<2>:: - serial_invoke(const int m, - ValueType *__restrict__ A) { - if (m > 2) - Kokkos::abort("InnerLU<2>::serial_invoke, assert failure (m<=2)"); - if (m <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<2>:: + serial_invoke(const int m, + ValueType *__restrict__ A) { + if (m > 2) + Kokkos::abort("InnerLU<2>::serial_invoke, assert failure (m<=2)"); + if (m <= 0) return 0; - switch (m) { - case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } - case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } - } - return 0; + switch (m) { + case 2: { InnerLU<2> inner(_as0, _as1); inner.serial_invoke(A); break; } + case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerLU<1>:: - serial_invoke(const int m, - ValueType *__restrict__ A) { - if (m > 1) - Kokkos::abort("InnerLU<1>::serial_invoke, assert failure (m<=1)"); - if (m <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerLU<1>:: + serial_invoke(const int m, + ValueType *__restrict__ A) { + if (m > 1) + Kokkos::abort("InnerLU<1>::serial_invoke, assert failure (m<=1)"); + if (m <= 0) return 0; - switch (m) { - case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } - } - return 0; + switch (m) { + case 1: { InnerLU<1> inner(_as0, _as1); inner.serial_invoke(A); break; } } + return 0; + } - // template - // template - // KOKKOS_INLINE_FUNCTION - // int - // InnerLU:: - // serial_invoke(const int m, const int n, - // ValueType *__restrict__ A) { - // if (m <= 0 || n <= 0) return 0; - // const int k = m < n ? m : n; - // for (int p=0;p + // template + // KOKKOS_INLINE_FUNCTION + // int + // InnerLU:: + // serial_invoke(const int m, const int n, + // ValueType *__restrict__ A) { + // if (m <= 0 || n <= 0) return 0; + // const int k = m < n ? m : n; + // for (int p=0;p - struct InnerMultipleDotProduct { - const int _as0, _as1, _xs0, _ys0; - - KOKKOS_INLINE_FUNCTION - InnerMultipleDotProduct(const int as0, const int as1, - const int xs0, - const int ys0) - : _as0(as0), _as1(as1), - _xs0(xs0), - _ys0(ys0) {} - - template - KOKKOS_INLINE_FUNCTION - int - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y); - - template - KOKKOS_INLINE_FUNCTION - int - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y); - }; - } + + template + struct InnerMultipleDotProduct { + const int _as0, _as1, _xs0, _ys0; + + KOKKOS_INLINE_FUNCTION + InnerMultipleDotProduct(const int as0, const int as1, + const int xs0, + const int ys0) + : _as0(as0), _as1(as1), + _xs0(xs0), + _ys0(ys0) {} + + template + KOKKOS_INLINE_FUNCTION + int + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y); + + template + KOKKOS_INLINE_FUNCTION + int + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y); + }; } + #endif diff --git a/src/batched/KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp index 0846b4c5aa..205fc9a6fc 100644 --- a/src/batched/KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerMultipleDotProduct_Serial_Impl.hpp @@ -7,307 +7,306 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerMultipleDotProduct_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Dot Product for GEMV - /// ==================== - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y) { - if (n <= 0) return 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0; - - // unroll by rows - ValueType - y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0, y_4 = 0; + + /// + /// Dot Product for GEMV + /// ==================== + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y) { + if (n <= 0) return 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0, i4 = 4*_as0; + + // unroll by rows + ValueType + y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0, y_4 = 0; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y) { - if (!n) return 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0; - - // unroll by rows - ValueType - y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0; + y[0*_ys0] += alpha*y_0; + y[1*_ys0] += alpha*y_1; + y[2*_ys0] += alpha*y_2; + y[3*_ys0] += alpha*y_3; + y[4*_ys0] += alpha*y_4; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y) { + if (!n) return 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0, i3 = 3*_as0; + + // unroll by rows + ValueType + y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y) { - if (n <= 0) return 0; - - const int - i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0; - - // unroll by rows - ValueType - y_0 = 0, y_1 = 0, y_2 = 0; + y[0*_ys0] += alpha*y_0; + y[1*_ys0] += alpha*y_1; + y[2*_ys0] += alpha*y_2; + y[3*_ys0] += alpha*y_3; + + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y) { + if (n <= 0) return 0; + + const int + i0 = 0*_as0, i1 = 1*_as0, i2 = 2*_as0; + + // unroll by rows + ValueType + y_0 = 0, y_1 = 0, y_2 = 0; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y) { - if (n <= 0) return 0; - - const int - i0 = 0*_as0, i1 = 1*_as0; - - // unroll by rows - ValueType - y_0 = 0, y_1 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y) { + if (n <= 0) return 0; + + const int + i0 = 0*_as0, i1 = 1*_as0; + + // unroll by rows + ValueType + y_0 = 0, y_1 = 0; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int n, - /**/ ValueType *__restrict__ y) { - if (n <= 0) return 0; - - // unroll by rows - ValueType - y_0 = 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int n, + /**/ ValueType *__restrict__ y) { + if (n <= 0) return 0; + + // unroll by rows + ValueType + y_0 = 0; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<5>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y) { - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 5: { InnerMultipleDotProduct<5> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 4: { InnerMultipleDotProduct<4> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<5>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y) { + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 5: { InnerMultipleDotProduct<5> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 4: { InnerMultipleDotProduct<4> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<4>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y) { - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 4: { InnerMultipleDotProduct<4> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<4>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y) { + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 4: { InnerMultipleDotProduct<4> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<3>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y) { - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<3>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y) { + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 3: { InnerMultipleDotProduct<3> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<2>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y) { - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<2>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y) { + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 2: { InnerMultipleDotProduct<2> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } + case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerMultipleDotProduct<1>:: - serial_invoke(const ScalarType alpha, - const ValueType *__restrict__ A, - const ValueType *__restrict__ x, - const int m, const int n, - /**/ ValueType *__restrict__ y) { - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerMultipleDotProduct<1>:: + serial_invoke(const ScalarType alpha, + const ValueType *__restrict__ A, + const ValueType *__restrict__ x, + const int m, const int n, + /**/ ValueType *__restrict__ y) { + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 1: { InnerMultipleDotProduct<1> inner(_as0, _as1, _xs0, _ys0); inner.serial_invoke(alpha, A, x, n, y); break; } } + return 0; } } + #endif diff --git a/src/batched/KokkosBatched_InnerTrsm_Decl.hpp b/src/batched/KokkosBatched_InnerTrsm_Decl.hpp index 02391e51ce..31d41cfd12 100644 --- a/src/batched/KokkosBatched_InnerTrsm_Decl.hpp +++ b/src/batched/KokkosBatched_InnerTrsm_Decl.hpp @@ -4,118 +4,117 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) - namespace KokkosBatched { - namespace Experimental { - // specialized for different m and n - // Solve L(m x m) X(m x n) = B(m x n) - template - struct InnerTrsmLeftLowerUnitDiag { - const int _as0, _as1, _bs0, _bs1; + + // specialized for different m and n + // Solve L(m x m) X(m x n) = B(m x n) + template + struct InnerTrsmLeftLowerUnitDiag { + const int _as0, _as1, _bs0, _bs1; - KOKKOS_INLINE_FUNCTION - InnerTrsmLeftLowerUnitDiag(const int as0, const int as1, - const int bs0, const int bs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1) {} + KOKKOS_INLINE_FUNCTION + InnerTrsmLeftLowerUnitDiag(const int as0, const int as1, + const int bs0, const int bs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1) {} - // trisolve - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B); - - // for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B); - }; - - // specialized for different m and n - // Solve L(m x m) X(m x n) = B(m x n) - template - struct InnerTrsmLeftLowerNonUnitDiag { - const int _as0, _as1, _bs0, _bs1; - - KOKKOS_INLINE_FUNCTION - InnerTrsmLeftLowerNonUnitDiag(const int as0, const int as1, - const int bs0, const int bs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1) {} + // trisolve + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B); + + // for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B); + }; + + // specialized for different m and n + // Solve L(m x m) X(m x n) = B(m x n) + template + struct InnerTrsmLeftLowerNonUnitDiag { + const int _as0, _as1, _bs0, _bs1; + + KOKKOS_INLINE_FUNCTION + InnerTrsmLeftLowerNonUnitDiag(const int as0, const int as1, + const int bs0, const int bs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1) {} - // trisolve - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B); - - // for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B); - }; - - // specialized for different m and n - // Solve U(m x m) X(m x n) = B(m x n) - template - struct InnerTrsmLeftUpperUnitDiag { - const int _as0, _as1, _bs0, _bs1; - - KOKKOS_INLINE_FUNCTION - InnerTrsmLeftUpperUnitDiag(const int as0, const int as1, - const int bs0, const int bs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1) {} + // trisolve + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B); + + // for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B); + }; + + // specialized for different m and n + // Solve U(m x m) X(m x n) = B(m x n) + template + struct InnerTrsmLeftUpperUnitDiag { + const int _as0, _as1, _bs0, _bs1; + + KOKKOS_INLINE_FUNCTION + InnerTrsmLeftUpperUnitDiag(const int as0, const int as1, + const int bs0, const int bs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1) {} - // trisolve - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B); - - // for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B); - }; - - // specialized for different m and n - // Solve U(m x m) X(m x n) = B(m x n) - template - struct InnerTrsmLeftUpperNonUnitDiag { - const int _as0, _as1, _bs0, _bs1; - - KOKKOS_INLINE_FUNCTION - InnerTrsmLeftUpperNonUnitDiag(const int as0, const int as1, - const int bs0, const int bs1) - : _as0(as0), _as1(as1), - _bs0(bs0), _bs1(bs1) {} + // trisolve + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B); + + // for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B); + }; + + // specialized for different m and n + // Solve U(m x m) X(m x n) = B(m x n) + template + struct InnerTrsmLeftUpperNonUnitDiag { + const int _as0, _as1, _bs0, _bs1; + + KOKKOS_INLINE_FUNCTION + InnerTrsmLeftUpperNonUnitDiag(const int as0, const int as1, + const int bs0, const int bs1) + : _as0(as0), _as1(as1), + _bs0(bs0), _bs1(bs1) {} - // trisolve - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B); - - // for remainder - template - KOKKOS_INLINE_FUNCTION - int serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B); - }; - - } + // trisolve + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B); + + // for remainder + template + KOKKOS_INLINE_FUNCTION + int serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B); + }; + } + #endif diff --git a/src/batched/KokkosBatched_InnerTrsm_Serial_Impl.hpp b/src/batched/KokkosBatched_InnerTrsm_Serial_Impl.hpp index 6f0f82b962..e034685cd4 100644 --- a/src/batched/KokkosBatched_InnerTrsm_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InnerTrsm_Serial_Impl.hpp @@ -7,1481 +7,1480 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_InnerTrsm_Decl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Fixed size TRSM - /// ================ - /// L(m x m) X(m x n) = B (m x n) - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p, - ValueType &b_4p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; - b_4p = B[4*_bs0+p*_bs1]; + + /// + /// Fixed size TRSM + /// ================ + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p, + ValueType &b_4p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; + b_4p = B[4*_bs0+p*_bs1]; - // 0 iteration - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; - b_3p -= a_30 * b_0p; - b_4p -= a_40 * b_0p; - - // 1 iteration - b_2p -= a_21 * b_1p; - b_3p -= a_31 * b_1p; - b_4p -= a_41 * b_1p; - - // 2 iteration - b_3p -= a_32 * b_2p; - b_4p -= a_42 * b_2p; - - // 3 iteration - b_4p -= a_43 * b_3p; - - // store - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - B[4*_bs0+p*_bs1] = b_4p; - }; + // 0 iteration + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; + b_3p -= a_30 * b_0p; + b_4p -= a_40 * b_0p; + + // 1 iteration + b_2p -= a_21 * b_1p; + b_3p -= a_31 * b_1p; + b_4p -= a_41 * b_1p; + + // 2 iteration + b_3p -= a_32 * b_2p; + b_4p -= a_42 * b_2p; + + // 3 iteration + b_4p -= a_43 * b_3p; + + // store + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + B[4*_bs0+p*_bs1] = b_4p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; - // 0 iteration - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; - b_3p -= a_30 * b_0p; + // 0 iteration + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; + b_3p -= a_30 * b_0p; - // 1 iteration - b_2p -= a_21 * b_1p; - b_3p -= a_31 * b_1p; + // 1 iteration + b_2p -= a_21 * b_1p; + b_3p -= a_31 * b_1p; - // 2 iteration - b_3p -= a_32 * b_2p; + // 2 iteration + b_3p -= a_32 * b_2p; - // store - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - }; + // store + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p) { - - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p) { + + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; - // 0 iteration - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; + // 0 iteration + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; - // 1 iteration - b_2p -= a_21 * b_1p; + // 1 iteration + b_2p -= a_21 * b_1p; - // store - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - }; + // store + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p) { - - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p) { + + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; - // 0 iteration - b_1p -= a_10 * b_0p; + // 0 iteration + b_1p -= a_10 * b_0p; - // store - B[1*_bs0+p*_bs1] = b_1p; - }; + // store + B[1*_bs0+p*_bs1] = b_1p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - return 0; - } + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + return 0; + } - /// - /// TRSM - /// ==== - /// L(m x m) X(m x n) = B (m x n) + /// + /// TRSM + /// ==== + /// L(m x m) X(m x n) = B (m x n) - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 5) - Kokkos::abort("InnerTrsmLeftLowerUnitDiag<5>::serial_invoke, assert failure (m<=5)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 5: { InnerTrsmLeftLowerUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 4: { InnerTrsmLeftLowerUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 5) + Kokkos::abort("InnerTrsmLeftLowerUnitDiag<5>::serial_invoke, assert failure (m<=5)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 5: { InnerTrsmLeftLowerUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 4: { InnerTrsmLeftLowerUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 4) - Kokkos::abort("InnerTrsmLeftLowerUnitDiag<4>::serial_invoke, assert failure (m<=4)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 4: { InnerTrsmLeftLowerUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 4) + Kokkos::abort("InnerTrsmLeftLowerUnitDiag<4>::serial_invoke, assert failure (m<=4)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 4: { InnerTrsmLeftLowerUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 3) - Kokkos::abort("InnerTrsmLeftLowerUnitDiag<3>::serial_invoke, assert failure (m<=3)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 3) + Kokkos::abort("InnerTrsmLeftLowerUnitDiag<3>::serial_invoke, assert failure (m<=3)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 3: { InnerTrsmLeftLowerUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 2) - Kokkos::abort("InnerTrsmLeftLowerUnitDiag<2>::serial_invoke, assert failure (m<=2)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 2) + Kokkos::abort("InnerTrsmLeftLowerUnitDiag<2>::serial_invoke, assert failure (m<=2)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 2: { InnerTrsmLeftLowerUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 1) - Kokkos::abort("InnerTrsmLeftLowerUnitDiag<1>::serial_invoke, assert failure (m<=1)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 1) + Kokkos::abort("InnerTrsmLeftLowerUnitDiag<1>::serial_invoke, assert failure (m<=1)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 1: { InnerTrsmLeftLowerUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } + return 0; + } - /// - /// Fixed size TRSM - /// ================ - /// L(m x m) X(m x n) = B (m x n) - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], - a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1], - // a_33 = A[3*_as0+3*_as1], - // a_44 = A[4*_as0+4*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], - inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1], - inv_a_44 = static_cast(1.0)/A[4*_as0+4*_as1]; + /// + /// Fixed size TRSM + /// ================ + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1], + a_40 = A[4*_as0+0*_as1], a_41 = A[4*_as0+1*_as1], a_42 = A[4*_as0+2*_as1], a_43 = A[4*_as0+3*_as1]; + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1], + // a_33 = A[3*_as0+3*_as1], + // a_44 = A[4*_as0+4*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], + inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1], + inv_a_44 = static_cast(1.0)/A[4*_as0+4*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p, - ValueType &b_4p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; - b_4p = B[4*_bs0+p*_bs1]; - - // 0 iteration - b_0p *= inv_a_00; /* b_0p /= a_00;*/ - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; - b_3p -= a_30 * b_0p; - b_4p -= a_40 * b_0p; - - // 1 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_2p -= a_21 * b_1p; - b_3p -= a_31 * b_1p; - b_4p -= a_41 * b_1p; + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p, + ValueType &b_4p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; + b_4p = B[4*_bs0+p*_bs1]; + + // 0 iteration + b_0p *= inv_a_00; /* b_0p /= a_00;*/ + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; + b_3p -= a_30 * b_0p; + b_4p -= a_40 * b_0p; + + // 1 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_2p -= a_21 * b_1p; + b_3p -= a_31 * b_1p; + b_4p -= a_41 * b_1p; - // 2 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ - b_3p -= a_32 * b_2p; - b_4p -= a_42 * b_2p; + // 2 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ + b_3p -= a_32 * b_2p; + b_4p -= a_42 * b_2p; - // 3 iteration - b_3p *= inv_a_33; /* b_3p /= a_33; */ - b_4p -= a_43 * b_3p; + // 3 iteration + b_3p *= inv_a_33; /* b_3p /= a_33; */ + b_4p -= a_43 * b_3p; - // 4 iteration - b_4p *= inv_a_44; /* b_4p /= a_44; */ + // 4 iteration + b_4p *= inv_a_44; /* b_4p /= a_44; */ - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - B[4*_bs0+p*_bs1] = b_4p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + B[4*_bs0+p*_bs1] = b_4p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], - a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1], - // a_33 = A[3*_as0+3*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], - inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1], + a_30 = A[3*_as0+0*_as1], a_31 = A[3*_as0+1*_as1], a_32 = A[3*_as0+2*_as1]; + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1], + // a_33 = A[3*_as0+3*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], + inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; - - // 0 iteration - b_0p *= inv_a_00; /* b_0p /= a_00;*/ - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; - b_3p -= a_30 * b_0p; - - // 1 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_2p -= a_21 * b_1p; - b_3p -= a_31 * b_1p; + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; + + // 0 iteration + b_0p *= inv_a_00; /* b_0p /= a_00;*/ + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; + b_3p -= a_30 * b_0p; + + // 1 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_2p -= a_21 * b_1p; + b_3p -= a_31 * b_1p; - // 2 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ - b_3p -= a_32 * b_2p; + // 2 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ + b_3p -= a_32 * b_2p; - // 3 iteration - b_3p *= inv_a_33; /* b_3p /= a_33; */ + // 3 iteration + b_3p *= inv_a_33; /* b_3p /= a_33; */ - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1], - a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1], + a_20 = A[2*_as0+0*_as1], a_21 = A[2*_as0+1*_as1]; + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - - // 0 iteration - b_0p *= inv_a_00; /* b_0p /= a_00;*/ - b_1p -= a_10 * b_0p; - b_2p -= a_20 * b_0p; - - // 1 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_2p -= a_21 * b_1p; + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + + // 0 iteration + b_0p *= inv_a_00; /* b_0p /= a_00;*/ + b_1p -= a_10 * b_0p; + b_2p -= a_20 * b_0p; + + // 1 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_2p -= a_21 * b_1p; - // 2 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ + // 2 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_10 = A[1*_as0+0*_as1]; - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_10 = A[1*_as0+0*_as1]; + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; - // 0 iteration - b_0p *= inv_a_00; /* b_0p /= a_00;*/ - b_1p -= a_10 * b_0p; + // 0 iteration + b_0p *= inv_a_00; /* b_0p /= a_00;*/ + b_1p -= a_10 * b_0p; - // 1 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ + // 1 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; - // const ValueType - // a_00 = A[0*_as0+0*_as1]; + // const ValueType + // a_00 = A[0*_as0+0*_as1]; - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1]; + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p) { - B[0*_bs0+p*_bs1] *= inv_a_00; /* b_0p /= a_00;*/ - }; + auto trsv = [&](const int p, + ValueType &b_0p) { + B[0*_bs0+p*_bs1] *= inv_a_00; /* b_0p /= a_00;*/ + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 5) - Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<5>::serial_invoke, assert failure (m<=5)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 5: { InnerTrsmLeftLowerNonUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 4: { InnerTrsmLeftLowerNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + + /// + /// TRSM + /// ============== + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 5) + Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<5>::serial_invoke, assert failure (m<=5)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 5: { InnerTrsmLeftLowerNonUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 4: { InnerTrsmLeftLowerNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 4) - Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<4>::serial_invoke, assert failure (m<=4)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 4: { InnerTrsmLeftLowerNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 4) + Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<4>::serial_invoke, assert failure (m<=4)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 4: { InnerTrsmLeftLowerNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 3) - Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<3>::serial_invoke, assert failure (m<=3)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 3) + Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<3>::serial_invoke, assert failure (m<=3)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 3: { InnerTrsmLeftLowerNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 2) - Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<2>::serial_invoke, assert failure (m<=2)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 2) + Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<2>::serial_invoke, assert failure (m<=2)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 2: { InnerTrsmLeftLowerNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftLowerNonUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 1) - Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<1>::serial_invoke, assert failure (m<=1)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftLowerNonUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 1) + Kokkos::abort("InnerTrsmLeftLowerNonUnitDiag<1>::serial_invoke, assert failure (m<=1)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 1: { InnerTrsmLeftLowerNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } + return 0; + } - /// - /// Fixed size TRSM - /// ================ - /// L(m x m) X(m x n) = B (m x n) - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - /**/ a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], - /**/ a_34 = A[3*_as0+4*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p, - ValueType &b_4p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; - b_4p = B[4*_bs0+p*_bs1]; + /// + /// Fixed size TRSM + /// ================ + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + /**/ a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], + /**/ a_34 = A[3*_as0+4*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p, + ValueType &b_4p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; + b_4p = B[4*_bs0+p*_bs1]; - // 0 iteration - b_0p -= a_04 * b_4p; - b_1p -= a_14 * b_4p; - b_2p -= a_24 * b_4p; - b_3p -= a_34 * b_4p; - - // 1 iteration - b_0p -= a_03 * b_3p; - b_1p -= a_13 * b_3p; - b_2p -= a_23 * b_3p; - - // 2 iteration - b_0p -= a_02 * b_2p; - b_1p -= a_12 * b_2p; - - // 1 iteration - b_0p -= a_01 * b_1p; - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - }; + // 0 iteration + b_0p -= a_04 * b_4p; + b_1p -= a_14 * b_4p; + b_2p -= a_24 * b_4p; + b_3p -= a_34 * b_4p; + + // 1 iteration + b_0p -= a_03 * b_3p; + b_1p -= a_13 * b_3p; + b_2p -= a_23 * b_3p; + + // 2 iteration + b_0p -= a_02 * b_2p; + b_1p -= a_12 * b_2p; + + // 1 iteration + b_0p -= a_01 * b_1p; + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - /**/ a_23 = A[2*_as0+3*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + /**/ a_23 = A[2*_as0+3*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; - // 0 iteration - b_0p -= a_03 * b_3p; - b_1p -= a_13 * b_3p; - b_2p -= a_23 * b_3p; - - // 1 iteration - b_0p -= a_02 * b_2p; - b_1p -= a_12 * b_2p; - - // 2 iteration - b_0p -= a_01 * b_1p; - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - }; + // 0 iteration + b_0p -= a_03 * b_3p; + b_1p -= a_13 * b_3p; + b_2p -= a_23 * b_3p; + + // 1 iteration + b_0p -= a_02 * b_2p; + b_1p -= a_12 * b_2p; + + // 2 iteration + b_0p -= a_01 * b_1p; + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - /**/ a_12 = A[1*_as0+2*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + /**/ a_12 = A[1*_as0+2*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; - // 0 iteration - b_0p -= a_02 * b_2p; - b_1p -= a_12 * b_2p; + // 0 iteration + b_0p -= a_02 * b_2p; + b_1p -= a_12 * b_2p; - // 1 iteration - b_0p -= a_01 * b_1p; + // 1 iteration + b_0p -= a_01 * b_1p; - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1]; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; - // 0 iteration - b_0p -= a_01 * b_1p; + // 0 iteration + b_0p -= a_01 * b_1p; - // store - B[0*_bs0+p*_bs1] = b_0p; - }; + // store + B[0*_bs0+p*_bs1] = b_0p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - return 0; - } + return 0; + } - /// - /// TRSM - /// ==== - /// L(m x m) X(m x n) = B (m x n) - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 5) - Kokkos::abort("InnerTrsmLeftUpperUnitDiag<5>::serial_invoke, assert failure (m<=5)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 5: { InnerTrsmLeftUpperUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 4: { InnerTrsmLeftUpperUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + return 0; + } + + /// + /// TRSM + /// ==== + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 5) + Kokkos::abort("InnerTrsmLeftUpperUnitDiag<5>::serial_invoke, assert failure (m<=5)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 5: { InnerTrsmLeftUpperUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 4: { InnerTrsmLeftUpperUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 4) - Kokkos::abort("InnerTrsmLeftUpperUnitDiag<4>::serial_invoke, assert failure (m<=4)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 4: { InnerTrsmLeftUpperUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 4) + Kokkos::abort("InnerTrsmLeftUpperUnitDiag<4>::serial_invoke, assert failure (m<=4)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 4: { InnerTrsmLeftUpperUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 3) - Kokkos::abort("InnerTrsmLeftUpperUnitDiag<3>::serial_invoke, assert failure (m<=3)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 3) + Kokkos::abort("InnerTrsmLeftUpperUnitDiag<3>::serial_invoke, assert failure (m<=3)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 3: { InnerTrsmLeftUpperUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 2) - Kokkos::abort("InnerTrsmLeftUpperUnitDiag<2>::serial_invoke, assert failure (m<=2)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 2) + Kokkos::abort("InnerTrsmLeftUpperUnitDiag<2>::serial_invoke, assert failure (m<=2)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 2: { InnerTrsmLeftUpperUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 1) - Kokkos::abort("InnerTrsmLeftUpperUnitDiag<1>::serial_invoke, assert failure (m<=1)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 1) + Kokkos::abort("InnerTrsmLeftUpperUnitDiag<1>::serial_invoke, assert failure (m<=1)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 1: { InnerTrsmLeftUpperUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } + return 0; + } - /// - /// Fixed size TRSM - /// ================ - /// L(m x m) X(m x n) = B (m x n) - - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], - /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], - /**/ a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], - /**/ a_34 = A[3*_as0+4*_as1]; + /// + /// Fixed size TRSM + /// ================ + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], a_04 = A[0*_as0+4*_as1], + /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], a_14 = A[1*_as0+4*_as1], + /**/ a_23 = A[2*_as0+3*_as1], a_24 = A[2*_as0+4*_as1], + /**/ a_34 = A[3*_as0+4*_as1]; - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1], - // a_33 = A[3*_as0+3*_as1], - // a_44 = A[4*_as0+4*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], - inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1], - inv_a_44 = static_cast(1.0)/A[4*_as0+4*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p, - ValueType &b_4p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; - b_4p = B[4*_bs0+p*_bs1]; + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1], + // a_33 = A[3*_as0+3*_as1], + // a_44 = A[4*_as0+4*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], + inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1], + inv_a_44 = static_cast(1.0)/A[4*_as0+4*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p, + ValueType &b_4p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; + b_4p = B[4*_bs0+p*_bs1]; - // 0 iteration - b_4p *= inv_a_44; /* b_4p /= a_44;*/ - b_3p -= a_34 * b_4p; - b_2p -= a_24 * b_4p; - b_1p -= a_14 * b_4p; - b_0p -= a_04 * b_4p; - - // 1 iterationls - b_3p *= inv_a_33; /* b_3p /= a_33;*/ - b_2p -= a_23 * b_3p; - b_1p -= a_13 * b_3p; - b_0p -= a_03 * b_3p; - - // 2 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ - b_1p -= a_12 * b_2p; - b_0p -= a_02 * b_2p; - - // 3 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_0p -= a_01 * b_1p; - - // 4 iteration - b_0p *= inv_a_00; /* b_0p /= a_00; */ - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - B[4*_bs0+p*_bs1] = b_4p; - }; + // 0 iteration + b_4p *= inv_a_44; /* b_4p /= a_44;*/ + b_3p -= a_34 * b_4p; + b_2p -= a_24 * b_4p; + b_1p -= a_14 * b_4p; + b_0p -= a_04 * b_4p; + + // 1 iterationls + b_3p *= inv_a_33; /* b_3p /= a_33;*/ + b_2p -= a_23 * b_3p; + b_1p -= a_13 * b_3p; + b_0p -= a_03 * b_3p; + + // 2 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ + b_1p -= a_12 * b_2p; + b_0p -= a_02 * b_2p; + + // 3 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_0p -= a_01 * b_1p; + + // 4 iteration + b_0p *= inv_a_00; /* b_0p /= a_00; */ + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + B[4*_bs0+p*_bs1] = b_4p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], - /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], - /**/ a_23 = A[2*_as0+3*_as1]; - - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1], - // a_33 = A[3*_as0+3*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], - inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p, - ValueType &b_3p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - b_3p = B[3*_bs0+p*_bs1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], a_03 = A[0*_as0+3*_as1], + /**/ a_12 = A[1*_as0+2*_as1], a_13 = A[1*_as0+3*_as1], + /**/ a_23 = A[2*_as0+3*_as1]; + + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1], + // a_33 = A[3*_as0+3*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1], + inv_a_33 = static_cast(1.0)/A[3*_as0+3*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p, + ValueType &b_3p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + b_3p = B[3*_bs0+p*_bs1]; - // 0 iteration - b_3p *= inv_a_33; /* b_3p /= a_33;*/ - b_2p -= a_23 * b_3p; - b_1p -= a_13 * b_3p; - b_0p -= a_03 * b_3p; - - // 1 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ - b_1p -= a_12 * b_2p; - b_0p -= a_02 * b_2p; - - // 2 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_0p -= a_01 * b_1p; - - // 3 iteration - b_0p *= inv_a_00; /* b_0p /= a_00; */ - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - B[3*_bs0+p*_bs1] = b_3p; - }; + // 0 iteration + b_3p *= inv_a_33; /* b_3p /= a_33;*/ + b_2p -= a_23 * b_3p; + b_1p -= a_13 * b_3p; + b_0p -= a_03 * b_3p; + + // 1 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ + b_1p -= a_12 * b_2p; + b_0p -= a_02 * b_2p; + + // 2 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_0p -= a_01 * b_1p; + + // 3 iteration + b_0p *= inv_a_00; /* b_0p /= a_00; */ + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + B[3*_bs0+p*_bs1] = b_3p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; - const ValueType - a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], - /**/ a_12 = A[1*_as0+2*_as1]; + const ValueType + a_01 = A[0*_as0+1*_as1], a_02 = A[0*_as0+2*_as1], + /**/ a_12 = A[1*_as0+2*_as1]; - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1], - // a_22 = A[2*_as0+2*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], - inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p, - ValueType &b_2p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - b_2p = B[2*_bs0+p*_bs1]; - - // 0 iteration - b_2p *= inv_a_22; /* b_2p /= a_22; */ - b_1p -= a_12 * b_2p; - b_0p -= a_02 * b_2p; - - // 1 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_0p -= a_01 * b_1p; - - // 2 iteration - b_0p *= inv_a_00; /* b_0p /= a_00; */ - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - B[2*_bs0+p*_bs1] = b_2p; - }; + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1], + // a_22 = A[2*_as0+2*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1], + inv_a_22 = static_cast(1.0)/A[2*_as0+2*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p, + ValueType &b_2p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + b_2p = B[2*_bs0+p*_bs1]; + + // 0 iteration + b_2p *= inv_a_22; /* b_2p /= a_22; */ + b_1p -= a_12 * b_2p; + b_0p -= a_02 * b_2p; + + // 1 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_0p -= a_01 * b_1p; + + // 2 iteration + b_0p *= inv_a_00; /* b_0p /= a_00; */ + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + B[2*_bs0+p*_bs1] = b_2p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - - const ValueType - a_01 = A[0*_as0+1*_as1]; - - // const ValueType - // a_00 = A[0*_as0+0*_as1], - // a_11 = A[1*_as0+1*_as1]; - - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], - inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1]; - - auto trsv = [&](const int p, - ValueType &b_0p, - ValueType &b_1p) { - // load - b_0p = B[0*_bs0+p*_bs1]; - b_1p = B[1*_bs0+p*_bs1]; - - // 2 iteration - b_1p *= inv_a_11; /* b_1p /= a_11; */ - b_0p -= a_01 * b_1p; - - // 3 iteration - b_0p *= inv_a_00; /* b_0p /= a_00; */ - - // store - B[0*_bs0+p*_bs1] = b_0p; - B[1*_bs0+p*_bs1] = b_1p; - }; + return 0; + } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; + + const ValueType + a_01 = A[0*_as0+1*_as1]; + + // const ValueType + // a_00 = A[0*_as0+0*_as1], + // a_11 = A[1*_as0+1*_as1]; + + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1], + inv_a_11 = static_cast(1.0)/A[1*_as0+1*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p, + ValueType &b_1p) { + // load + b_0p = B[0*_bs0+p*_bs1]; + b_1p = B[1*_bs0+p*_bs1]; + + // 2 iteration + b_1p *= inv_a_11; /* b_1p /= a_11; */ + b_0p -= a_01 * b_1p; + + // 3 iteration + b_0p *= inv_a_00; /* b_0p /= a_00; */ + + // store + B[0*_bs0+p*_bs1] = b_0p; + B[1*_bs0+p*_bs1] = b_1p; + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int n, - /**/ ValueType *__restrict__ B) { - if (n <= 0) return 0; - // const ValueType - // a_00 = A[0*_as0+0*_as1]; + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int n, + /**/ ValueType *__restrict__ B) { + if (n <= 0) return 0; - const ValueType - inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1]; + // const ValueType + // a_00 = A[0*_as0+0*_as1]; - auto trsv = [&](const int p, - ValueType &b_0p) { - // 0 iteration - B[0*_bs0+p*_bs1] *= inv_a_00; /* b_0p /= a_00; */ - }; + const ValueType + inv_a_00 = static_cast(1.0)/A[0*_as0+0*_as1]; + + auto trsv = [&](const int p, + ValueType &b_0p) { + // 0 iteration + B[0*_bs0+p*_bs1] *= inv_a_00; /* b_0p /= a_00; */ + }; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<5>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 5) - Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<5>::serial_invoke, assert failure (m<=5)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 5: { InnerTrsmLeftUpperNonUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 4: { InnerTrsmLeftUpperNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + /// + /// TRSM + /// ==== + /// L(m x m) X(m x n) = B (m x n) + + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<5>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 5) + Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<5>::serial_invoke, assert failure (m<=5)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 5: { InnerTrsmLeftUpperNonUnitDiag<5> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 4: { InnerTrsmLeftUpperNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<4>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 4) - Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<4>::serial_invoke, assert failure (m<=4)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 4: { InnerTrsmLeftUpperNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<4>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 4) + Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<4>::serial_invoke, assert failure (m<=4)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 4: { InnerTrsmLeftUpperNonUnitDiag<4> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<3>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 3) - Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<3>::serial_invoke, assert failure (m<=3)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<3>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 3) + Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<3>::serial_invoke, assert failure (m<=3)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 3: { InnerTrsmLeftUpperNonUnitDiag<3> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<2>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 2) - Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<2>::serial_invoke, assert failure (m<=2)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<2>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 2) + Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<2>::serial_invoke, assert failure (m<=2)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 2: { InnerTrsmLeftUpperNonUnitDiag<2> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } + case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - template<> - template - KOKKOS_INLINE_FUNCTION - int - InnerTrsmLeftUpperNonUnitDiag<1>:: - serial_invoke(const ValueType *__restrict__ A, - const int m, const int n, - /**/ ValueType *__restrict__ B) { - if (m > 1) - Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<1>::serial_invoke, assert failure (m<=1)"); - if (m <= 0 || n <= 0) return 0; - switch (m) { - case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } - } - return 0; + return 0; + } + template<> + template + KOKKOS_INLINE_FUNCTION + int + InnerTrsmLeftUpperNonUnitDiag<1>:: + serial_invoke(const ValueType *__restrict__ A, + const int m, const int n, + /**/ ValueType *__restrict__ B) { + if (m > 1) + Kokkos::abort("InnerTrsmLeftUpperNonUnitDiag<1>::serial_invoke, assert failure (m<=1)"); + if (m <= 0 || n <= 0) return 0; + switch (m) { + case 1: { InnerTrsmLeftUpperNonUnitDiag<1> inner(_as0, _as1, _bs0, _bs1); inner.serial_invoke(A, n, B); break; } } - + return 0; } + } + #endif diff --git a/src/batched/KokkosBatched_InverseLU_Decl.hpp b/src/batched/KokkosBatched_InverseLU_Decl.hpp index c64799be5d..b2cb675734 100644 --- a/src/batched/KokkosBatched_InverseLU_Decl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Decl.hpp @@ -12,53 +12,52 @@ #include "KokkosBatched_SolveLU_Decl.hpp" namespace KokkosBatched { - namespace Experimental { - template - struct SerialInverseLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - const wViewType &w) { - typedef typename wViewType::value_type value_type; - // workspace w is always 1D view; reinterpret it - Kokkos::View - W(w.data(), A.extent(0), A.extent(1)); - - int r_val[3] = {}; - r_val[0] = SerialCopy::invoke(A, W); - r_val[1] = SerialSetIdentity::invoke(A); - r_val[2] = SerialSolveLU::invoke(W, A); - return r_val[0]+r_val[1]+r_val[2]; - } - }; - - template - struct TeamInverseLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const wViewType &w) { - typedef typename wViewType::value_type value_type; - // workspace w is always 1D view; reinterpret it - Kokkos::View - W(w.data(), A.extent(0), A.extent(1)); - - int r_val[3] = {}; - r_val[0] = TeamCopy::invoke(member, A, W); - r_val[1] = TeamSetIdentity::invoke(member, A); - r_val[2] = TeamSolveLU::invoke(member, W, A); - return r_val[0]+r_val[1]+r_val[2]; - } - }; + template + struct SerialInverseLU { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const wViewType &w) { + typedef typename wViewType::value_type value_type; + // workspace w is always 1D view; reinterpret it + Kokkos::View + W(w.data(), A.extent(0), A.extent(1)); + + int r_val[3] = {}; + r_val[0] = SerialCopy::invoke(A, W); + r_val[1] = SerialSetIdentity::invoke(A); + r_val[2] = SerialSolveLU::invoke(W, A); + return r_val[0]+r_val[1]+r_val[2]; + } + }; + + template + struct TeamInverseLU { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const wViewType &w) { + typedef typename wViewType::value_type value_type; + // workspace w is always 1D view; reinterpret it + Kokkos::View + W(w.data(), A.extent(0), A.extent(1)); + + int r_val[3] = {}; + r_val[0] = TeamCopy::invoke(member, A, W); + r_val[1] = TeamSetIdentity::invoke(member, A); + r_val[2] = TeamSolveLU::invoke(member, W, A); + return r_val[0]+r_val[1]+r_val[2]; + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp b/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp index b2ad7bedb3..cecf36fdf1 100644 --- a/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_InverseLU_Serial_Impl.hpp @@ -9,66 +9,66 @@ #include "KokkosBatched_SolveLU_Serial_Impl.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// ========= - /// - /// InverseLU no piv - /// + /// + /// Serial Impl + /// ========= + + /// + /// InverseLU no piv + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialInverseLU:: - invoke(const AViewType &A, - const WViewType &W) { - typedef typename AViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialInverseLU:: + invoke(const AViewType &A, + const WViewType &W) { + typedef typename AViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = A.extent(0), - n = A.extent(1); + const int + m = A.extent(0), + n = A.extent(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - static_assert(AViewType::rank == 2, "A should have two dimensions"); - static_assert(WViewType::rank == 1, "W should have one dimension"); - static_assert(std::is_same::value, "A and W should be on the same memory space"); - static_assert(!std::is_same::value, "W should be an contiguous 1D array"); - assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); - assert(m==n); + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + static_assert(AViewType::rank == 2, "A should have two dimensions"); + static_assert(WViewType::rank == 1, "W should have one dimension"); + static_assert(std::is_same::value, "A and W should be on the same memory space"); + static_assert(!std::is_same::value, "W should be an contiguous 1D array"); + assert(A.extent(0)*A.extent(1)*sizeof(typename AViewType::value_type) <= W.span()*sizeof(typename WViewType::value_type)); + assert(m==n); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - int r_val = 0; - if (A.stride(0) == 1) { - mkl_dgetrinp_compact (MKL_COL_MAJOR, n, - (double*)A.data(), A.stride(1), - (double*)W.data(), (MKL_INT)(n*n*vector_type::vector_length), - (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); + int r_val = 0; + if (A.stride(0) == 1) { + mkl_dgetrinp_compact (MKL_COL_MAJOR, n, + (double*)A.data(), A.stride(1), + (double*)W.data(), (MKL_INT)(n*n*vector_type::vector_length), + (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); - } else if (A.stride(1) == 1) { - mkl_dgetrinp_compact (MKL_ROW_MAJOR, n, - (double*)A.data(), A.stride(0), - (double*)W.data(), (MKL_INT)(n*n*vector_type::vector_length), - (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + } else if (A.stride(1) == 1) { + mkl_dgetrinp_compact (MKL_ROW_MAJOR, n, + (double*)A.data(), A.stride(0), + (double*)W.data(), (MKL_INT)(n*n*vector_type::vector_length), + (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - } } + #endif diff --git a/src/batched/KokkosBatched_LU_Decl.hpp b/src/batched/KokkosBatched_LU_Decl.hpp index 8113d4a65c..d9c217fe9f 100644 --- a/src/batched/KokkosBatched_LU_Decl.hpp +++ b/src/batched/KokkosBatched_LU_Decl.hpp @@ -8,54 +8,52 @@ #include "KokkosBatched_Vector.hpp" namespace KokkosBatched { - namespace Experimental { - template - struct SerialLU { - // no piv version - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - const typename MagnitudeScalarType::type tiny = 0); - }; + template + struct SerialLU { + // no piv version + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0); + }; - template - struct TeamLU { - // no piv version - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const typename MagnitudeScalarType::type tiny = 0); - }; + template + struct TeamLU { + // no piv version + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0); + }; - /// - /// Selective Interface - /// - template - struct LU { - // no piv version - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const typename MagnitudeScalarType::type tiny = 0) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialLU::invoke(A, tiny); - } else if (std::is_same::value) { - r_val = TeamLU::invoke(member, A, tiny); - } - return r_val; - } - }; + /// + /// Selective Interface + /// + template + struct LU { + // no piv version + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialLU::invoke(A, tiny); + } else if (std::is_same::value) { + r_val = TeamLU::invoke(member, A, tiny); + } + return r_val; + } + }; - } } #endif diff --git a/src/batched/KokkosBatched_LU_Serial_Impl.hpp b/src/batched/KokkosBatched_LU_Serial_Impl.hpp index 1cef00581e..51ebb3cd22 100644 --- a/src/batched/KokkosBatched_LU_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_LU_Serial_Impl.hpp @@ -7,83 +7,82 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_LU_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// ========= - /// - /// SerialLU no piv - /// + /// + /// Serial Impl + /// ========= + + /// + /// SerialLU no piv + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialLU:: - invoke(const AViewType &A, - const typename MagnitudeScalarType::type tiny) { - typedef typename AViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialLU:: + invoke(const AViewType &A, + const typename MagnitudeScalarType::type tiny) { + typedef typename AViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = A.dimension(0), - n = A.dimension(1); + const int + m = A.dimension(0), + n = A.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dgetrfnp_compact(MKL_COL_MAJOR, - m, n, - (double*)A.data(), A.stride_1(), - (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dgetrfnp_compact(MKL_ROW_MAJOR, - m, n, - (double*)A.data(), A.stride_0(), - (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dgetrfnp_compact(MKL_COL_MAJOR, + m, n, + (double*)A.data(), A.stride_1(), + (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dgetrfnp_compact(MKL_ROW_MAJOR, + m, n, + (double*)A.data(), A.stride_0(), + (MKL_INT*)&r_val, format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } + return r_val; + } #endif - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialLU:: - invoke(const AViewType &A, - const typename MagnitudeScalarType::type tiny) { - return SerialLU_Internal::invoke(A.extent(0), A.extent(1), - A.data(), A.stride_0(), A.stride_1(), - tiny); - } - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialLU:: - invoke(const AViewType &A, - const typename MagnitudeScalarType::type tiny) { - return SerialLU_Internal::invoke(A.extent(0), A.extent(1), + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialLU:: + invoke(const AViewType &A, + const typename MagnitudeScalarType::type tiny) { + return SerialLU_Internal::invoke(A.extent(0), A.extent(1), A.data(), A.stride_0(), A.stride_1(), tiny); - } - } + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialLU:: + invoke(const AViewType &A, + const typename MagnitudeScalarType::type tiny) { + return SerialLU_Internal::invoke(A.extent(0), A.extent(1), + A.data(), A.stride_0(), A.stride_1(), + tiny); + } + } + #endif diff --git a/src/batched/KokkosBatched_LU_Serial_Internal.hpp b/src/batched/KokkosBatched_LU_Serial_Internal.hpp index a08c4094cc..921f0c0e03 100644 --- a/src/batched/KokkosBatched_LU_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_LU_Serial_Internal.hpp @@ -10,137 +10,135 @@ #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" #include "KokkosBatched_Gemm_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - - template - struct SerialLU_Internal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, - ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny); - }; + /// + /// Serial Internal Impl + /// ==================== - template<> + template + struct SerialLU_Internal { template KOKKOS_INLINE_FUNCTION - int - SerialLU_Internal:: + static int invoke(const int m, const int n, ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny) { - const int k = (m < n ? m : n); - if (k <= 0) return 0; - - const auto abs_tiny = tiny > 0 ? tiny : -tiny; - const auto minus_abs_tiny = -abs_tiny; - - for (int p=0;p::type tiny); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialLU_Internal:: + invoke(const int m, const int n, + ValueType *__restrict__ A, const int as0, const int as1, + const typename MagnitudeScalarType::type tiny) { + const int k = (m < n ? m : n); + if (k <= 0) return 0; + + const auto abs_tiny = tiny > 0 ? tiny : -tiny; + const auto minus_abs_tiny = -abs_tiny; + + for (int p=0;p::real(alpha11_reference); - alpha11_reference += minus_abs_tiny*ValueType(alpha11_real < 0); - alpha11_reference += abs_tiny*ValueType(alpha11_real >= 0); - } - - const ValueType - alpha11 = A[p*as0+p*as1]; + ValueType + *__restrict__ a21 = A+(p+1)*as0+(p )*as1, + *__restrict__ A22 = A+(p+1)*as0+(p+1)*as1; + + if (tiny != 0) { + ValueType &alpha11_reference = A[p*as0+p*as1]; + const auto alpha11_real = Kokkos::Details::ArithTraits::real(alpha11_reference); + alpha11_reference += minus_abs_tiny*ValueType(alpha11_real < 0); + alpha11_reference += abs_tiny*ValueType(alpha11_real >= 0); + } + + const ValueType + alpha11 = A[p*as0+p*as1]; - for (int i=0;i - template - KOKKOS_INLINE_FUNCTION - int - SerialLU_Internal:: - invoke(const int m, const int n, - ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny) { - enum : int { - mbAlgo = Algo::LU::Blocked::mb() - }; - const typename MagnitudeScalarType::type one(1.0), minus_one(-1.0); - - const int k = (m < n ? m : n); - if (k <= 0) return 0; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialLU_Internal:: + invoke(const int m, const int n, + ValueType *__restrict__ A, const int as0, const int as1, + const typename MagnitudeScalarType::type tiny) { + enum : int { + mbAlgo = Algo::LU::Blocked::mb() + }; + const typename MagnitudeScalarType::type one(1.0), minus_one(-1.0); + + const int k = (m < n ? m : n); + if (k <= 0) return 0; - InnerLU lu(as0, as1); + InnerLU lu(as0, as1); - InnerTrsmLeftLowerUnitDiag trsm_llu(as0, as1, as0, as1); - InnerTrsmLeftLowerNonUnitDiag trsm_run(as1, as0, as1, as0); + InnerTrsmLeftLowerUnitDiag trsm_llu(as0, as1, as0, as1); + InnerTrsmLeftLowerNonUnitDiag trsm_run(as1, as0, as1, as0); - auto lu_factorize = [&](const int ib, - const int jb, - ValueType *__restrict__ AA) { - const int mb = mbAlgo; - const int kb = ib < jb ? ib : jb; - for (int p=0;p kb ? (kb-p) : mb; + auto lu_factorize = [&](const int ib, + const int jb, + ValueType *__restrict__ AA) { + const int mb = mbAlgo; + const int kb = ib < jb ? ib : jb; + for (int p=0;p kb ? (kb-p) : mb; - // diagonal block - ValueType *__restrict__ Ap = AA+p*as0+p*as1; + // diagonal block + ValueType *__restrict__ Ap = AA+p*as0+p*as1; - // lu on a block - lu.serial_invoke(pb, Ap); + // lu on a block + lu.serial_invoke(pb, Ap); - // dimension ABR - const int m_abr = ib-p-mb, n_abr = jb-p-mb; + // dimension ABR + const int m_abr = ib-p-mb, n_abr = jb-p-mb; - // trsm update - trsm_llu.serial_invoke(Ap, pb, n_abr, Ap+mb*as1); - trsm_run.serial_invoke(Ap, pb, m_abr, Ap+mb*as0); + // trsm update + trsm_llu.serial_invoke(Ap, pb, n_abr, Ap+mb*as1); + trsm_run.serial_invoke(Ap, pb, m_abr, Ap+mb*as0); - // gemm update - SerialGemmInternal:: - invoke(m_abr, n_abr, pb, - minus_one, - Ap+mb*as0, as0, as1, - Ap+mb*as1, as0, as1, - one, - Ap+mb*as0+mb*as1, as0, as1); - } - }; - - const bool is_small = true; //(m*n <= 64*64); - if (is_small) { - lu_factorize(m, n, A); - } else { - // // some cache blocking may need (not priority yet); - // lu_factorize(m, n, A); + // gemm update + SerialGemmInternal:: + invoke(m_abr, n_abr, pb, + minus_one, + Ap+mb*as0, as0, as1, + Ap+mb*as1, as0, as1, + one, + Ap+mb*as0+mb*as1, as0, as1); } + }; - return 0; + const bool is_small = true; //(m*n <= 64*64); + if (is_small) { + lu_factorize(m, n, A); + } else { + // // some cache blocking may need (not priority yet); + // lu_factorize(m, n, A); } + return 0; } + } + #endif diff --git a/src/batched/KokkosBatched_LU_Team_Impl.hpp b/src/batched/KokkosBatched_LU_Team_Impl.hpp index d68a31d7d7..4604de622c 100644 --- a/src/batched/KokkosBatched_LU_Team_Impl.hpp +++ b/src/batched/KokkosBatched_LU_Team_Impl.hpp @@ -7,46 +7,45 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_LU_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Impl - /// ========= - - /// - /// LU no piv - /// - - template - struct TeamLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, - const typename MagnitudeScalarType::type tiny = 0) { - return TeamLU_Internal::invoke(member, - A.extent(0), A.extent(1), - A.data(), A.stride_0(), A.stride_1(), - tiny); - } - }; + + /// + /// Team Impl + /// ========= + + /// + /// LU no piv + /// - template - struct TeamLU { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, const AViewType &A, - const typename MagnitudeScalarType::type tiny = 0) { - return TeamLU_Internal::invoke(member, + template + struct TeamLU { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0) { + return TeamLU_Internal::invoke(member, A.extent(0), A.extent(1), A.data(), A.stride_0(), A.stride_1(), tiny); - } - }; + } + }; + + template + struct TeamLU { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, const AViewType &A, + const typename MagnitudeScalarType::type tiny = 0) { + return TeamLU_Internal::invoke(member, + A.extent(0), A.extent(1), + A.data(), A.stride_0(), A.stride_1(), + tiny); + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_LU_Team_Internal.hpp b/src/batched/KokkosBatched_LU_Team_Internal.hpp index 5fc23cd3ff..291420953e 100644 --- a/src/batched/KokkosBatched_LU_Team_Internal.hpp +++ b/src/batched/KokkosBatched_LU_Team_Internal.hpp @@ -12,170 +12,168 @@ #include "KokkosBatched_Trsm_Team_Internal.hpp" #include "KokkosBatched_Gemm_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Internal Impl - /// ================== - - template - struct TeamLU_Internal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, - ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny); - }; + /// + /// Team Internal Impl + /// ================== - template<> + template + struct TeamLU_Internal { template KOKKOS_INLINE_FUNCTION - int - TeamLU_Internal:: - invoke(const MemberType &member, + static int + invoke(const MemberType &member, const int m, const int n, ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny) { - - const int k = (m < n ? m : n); - if (k <= 0) return 0; - - const auto abs_tiny = tiny > 0 ? tiny : -tiny; - const auto minus_abs_tiny = -abs_tiny; - - for (int p=0;p::real(alpha11_reference); - alpha11_reference += minus_abs_tiny*ValueType(alpha11_real < 0); - alpha11_reference += abs_tiny*ValueType(alpha11_real >= 0); - } + const typename MagnitudeScalarType::type tiny); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamLU_Internal:: + invoke(const MemberType &member, + const int m, const int n, + ValueType *__restrict__ A, const int as0, const int as1, + const typename MagnitudeScalarType::type tiny) { + + const int k = (m < n ? m : n); + if (k <= 0) return 0; + + const auto abs_tiny = tiny > 0 ? tiny : -tiny; + const auto minus_abs_tiny = -abs_tiny; + + for (int p=0;p::real(alpha11_reference); + alpha11_reference += minus_abs_tiny*ValueType(alpha11_real < 0); + alpha11_reference += abs_tiny*ValueType(alpha11_real >= 0); } + } - member.team_barrier(); - const ValueType - alpha11 = A[p*as0+p*as1]; - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend),[&](const int &i) { - // a21[i*as0] *= inv_alpha11; - a21[i*as0] /= alpha11; - }); + member.team_barrier(); + const ValueType + alpha11 = A[p*as0+p*as1]; + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend),[&](const int &i) { + // a21[i*as0] *= inv_alpha11; + a21[i*as0] /= alpha11; + }); - member.team_barrier(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend*jend),[&](const int &ij) { - // assume layout right for batched computation - const int i = ij/jend, j = ij%jend; - A22[i*as0+j*as1] -= a21[i*as0] * a12t[j*as1]; - }); - } - return 0; + member.team_barrier(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend*jend),[&](const int &ij) { + // assume layout right for batched computation + const int i = ij/jend, j = ij%jend; + A22[i*as0+j*as1] -= a21[i*as0] * a12t[j*as1]; + }); } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - TeamLU_Internal:: - invoke(const MemberType &member, - const int m, const int n, - ValueType *__restrict__ A, const int as0, const int as1, - const typename MagnitudeScalarType::type tiny) { - - enum : int { - mbAlgo = Algo::LU::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamLU_Internal:: + invoke(const MemberType &member, + const int m, const int n, + ValueType *__restrict__ A, const int as0, const int as1, + const typename MagnitudeScalarType::type tiny) { + + enum : int { + mbAlgo = Algo::LU::Blocked::mb() + }; - const int k = (m < n ? m : n); - if (k <= 0) return 0; + const int k = (m < n ? m : n); + if (k <= 0) return 0; - const typename MagnitudeScalarType::type one(1.0), minus_one(-1.0); + const typename MagnitudeScalarType::type one(1.0), minus_one(-1.0); - InnerLU lu(as0, as1); + InnerLU lu(as0, as1); - InnerTrsmLeftLowerUnitDiag trsm_llu(as0, as1, as0, as1); - InnerTrsmLeftLowerNonUnitDiag trsm_run(as1, as0, as1, as0); - auto lu_factorize = [&](const int ib, - const int jb, - ValueType *__restrict__ AA) { - const int tsize = member.team_size(); + InnerTrsmLeftLowerUnitDiag trsm_llu(as0, as1, as0, as1); + InnerTrsmLeftLowerNonUnitDiag trsm_run(as1, as0, as1, as0); + auto lu_factorize = [&](const int ib, + const int jb, + ValueType *__restrict__ AA) { + const int tsize = member.team_size(); + // Made this non-const in order to WORKAROUND issue #349 + int mb = mbAlgo; + int nb = ((jb-mb) + (ib-mb)) > 0? + ((jb-mb) + (ib-mb))/tsize + (((jb-mb) + (ib-mb))%tsize > 0): + 1; + const int kb = ib < jb ? ib : jb; + + for (int p=0;p kb ? (kb-p) : mb; + + // diagonal block + ValueType *__restrict__ Ap = AA+p*as0+p*as1; + + // lu on a block + member.team_barrier(); + if (member.team_rank() == 0) + lu.serial_invoke(pb, Ap); + member.team_barrier(); + // Made this non-const in order to WORKAROUND issue #349 - int mb = mbAlgo; - int nb = ((jb-mb) + (ib-mb)) > 0? - ((jb-mb) + (ib-mb))/tsize + (((jb-mb) + (ib-mb))%tsize > 0): - 1; - const int kb = ib < jb ? ib : jb; - - for (int p=0;p kb ? (kb-p) : mb; - - // diagonal block - ValueType *__restrict__ Ap = AA+p*as0+p*as1; - - // lu on a block - member.team_barrier(); - if (member.team_rank() == 0) - lu.serial_invoke(pb, Ap); - member.team_barrier(); - - // Made this non-const in order to WORKAROUND issue #349 - int - m_abr = ib-p-mb, n_abr = jb-p-mb, - mp_abr = m_abr%nb, np_abr = n_abr%nb, - mq_abr = (m_abr/nb)+(mp_abr>0), nq_abr = (n_abr/nb)+(np_abr>0); - - // trsm update - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,mq_abr+nq_abr), - [&](const int &ij) { - if (ij < nq_abr) { - const int j = (ij)*nb, qb = (j+nb) > n_abr ? np_abr : nb; - trsm_llu.serial_invoke(Ap, pb, qb, Ap+(j+mb)*as1); - } else { - const int i = (ij-nq_abr)*nb , qb = (i+nb) > m_abr ? mp_abr : nb; - trsm_run.serial_invoke(Ap, pb, qb, Ap+(i+mb)*as0); - } - }); - member.team_barrier(); - - // gemm update - TeamGemmInternal:: - invoke(member, - m_abr, n_abr, pb, - minus_one, - Ap+mb*as0, as0, as1, - Ap+mb*as1, as0, as1, - one, - Ap+mb*as0+mb*as1, as0, as1); - } - }; - - const bool is_small = true; //(m*n <= 64*64); - if (is_small) { - lu_factorize(m, n, A); - } else { - // // some cache blocking may need (not priority yet); - // lu_factorize(m, n, A); - } + int + m_abr = ib-p-mb, n_abr = jb-p-mb, + mp_abr = m_abr%nb, np_abr = n_abr%nb, + mq_abr = (m_abr/nb)+(mp_abr>0), nq_abr = (n_abr/nb)+(np_abr>0); + + // trsm update + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,mq_abr+nq_abr), + [&](const int &ij) { + if (ij < nq_abr) { + const int j = (ij)*nb, qb = (j+nb) > n_abr ? np_abr : nb; + trsm_llu.serial_invoke(Ap, pb, qb, Ap+(j+mb)*as1); + } else { + const int i = (ij-nq_abr)*nb , qb = (i+nb) > m_abr ? mp_abr : nb; + trsm_run.serial_invoke(Ap, pb, qb, Ap+(i+mb)*as0); + } + }); + member.team_barrier(); - return 0; + // gemm update + TeamGemmInternal:: + invoke(member, + m_abr, n_abr, pb, + minus_one, + Ap+mb*as0, as0, as1, + Ap+mb*as1, as0, as1, + one, + Ap+mb*as0+mb*as1, as0, as1); + } + }; + + const bool is_small = true; //(m*n <= 64*64); + if (is_small) { + lu_factorize(m, n, A); + } else { + // // some cache blocking may need (not priority yet); + // lu_factorize(m, n, A); } + + return 0; } } + #endif diff --git a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp index 0f6bdcd7ac..db21a13588 100644 --- a/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_LeftEigenvectorFromSchur_Serial_Internal.hpp @@ -8,141 +8,140 @@ #include "KokkosBatched_ShiftedTrsv_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialLeftEigenvectorFromSchurInternal { - /// Given a quasi upper triangular matrix S (m x m), this computes all left - /// eigenvectors. - /// - /// Parameters: - /// [in]m - /// A dimension of the square matrix S. - /// [in]S, [in]ss0, [in]ss1 - /// A quasi upper triangular part of Schur decomposition which is computed - /// A = U^H S U - /// [out]V, [in]vs0, [out]vs1 - /// A set of left eigen vectors. - /// [in]w - /// contiguous workspace that can hold complex array (m) - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ ValueType * S, const int ss0, const int ss1, - /* */ ValueType * V, const int vs0, const int vs1, - /* */ ValueType * w, - const int * blks) { - typedef ValueType value_type; - typedef Kokkos::Details::ArithTraits ats; - //typedef typename ats::mag_type mag_type; - typedef Kokkos::complex complex_type; - - const value_type zero(0), one(1); - /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); - - value_type *b = w; // consider complex case - - /// partitions used for loop iteration - Partition2x2 S_part2x2(ss0, ss1); - Partition3x3 S_part3x3(ss0, ss1); + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialLeftEigenvectorFromSchurInternal { + /// Given a quasi upper triangular matrix S (m x m), this computes all left + /// eigenvectors. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix S. + /// [in]S, [in]ss0, [in]ss1 + /// A quasi upper triangular part of Schur decomposition which is computed + /// A = U^H S U + /// [out]V, [in]vs0, [out]vs1 + /// A set of left eigen vectors. + /// [in]w + /// contiguous workspace that can hold complex array (m) + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * S, const int ss0, const int ss1, + /* */ ValueType * V, const int vs0, const int vs1, + /* */ ValueType * w, + const int * blks) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + //typedef typename ats::mag_type mag_type; + typedef Kokkos::complex complex_type; + + const value_type zero(0), one(1); + /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); + + value_type *b = w; // consider complex case + + /// partitions used for loop iteration + Partition2x2 S_part2x2(ss0, ss1); + Partition3x3 S_part3x3(ss0, ss1); - Partition2x1 V_part2x1(vs0); - Partition3x1 V_part3x1(vs0); + Partition2x1 V_part2x1(vs0); + Partition3x1 V_part3x1(vs0); - /// initial partition of S where ATL has a zero dimension - S_part2x2.partWithATL(S, m, m, 0, 0); - V_part2x1.partWithAT(V, m, 0); - - //const mag_type tol = ats::epsilon(); - int m_stl = 0; - for (;m_stl<(m-1);) { - /// part 2x2 into 3x3 - const int mA11 = blks[m_stl]; - assert( ((mA11 == 1) || (mA11 == 2)) && "LeftEigenvectorFromSchur: blk is not 1x1 nor 2x2"); - - S_part3x3.partWithABR(S_part2x2, mA11, mA11); - V_part3x1.partWithAB(V_part2x1, mA11); - - const int m_stl_plus_mA11 = m_stl+mA11; - if (mA11 == 1) { - /// real eigenvalue - const value_type lambda = *S_part3x3.A11; - - /// initialize a left hand side - b[m_stl] = one; - for (int j=0;j<(m-m_stl_plus_mA11);++j) - b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; - - /// perform shifted trsv (transposed) - SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, - S_part3x3.A22, ss1, ss0, - b+m_stl_plus_mA11, 1, - blks+m_stl_plus_mA11); + /// initial partition of S where ATL has a zero dimension + S_part2x2.partWithATL(S, m, m, 0, 0); + V_part2x1.partWithAT(V, m, 0); + + //const mag_type tol = ats::epsilon(); + int m_stl = 0; + for (;m_stl<(m-1);) { + /// part 2x2 into 3x3 + const int mA11 = blks[m_stl]; + assert( ((mA11 == 1) || (mA11 == 2)) && "LeftEigenvectorFromSchur: blk is not 1x1 nor 2x2"); + + S_part3x3.partWithABR(S_part2x2, mA11, mA11); + V_part3x1.partWithAB(V_part2x1, mA11); + + const int m_stl_plus_mA11 = m_stl+mA11; + if (mA11 == 1) { + /// real eigenvalue + const value_type lambda = *S_part3x3.A11; + + /// initialize a left hand side + b[m_stl] = one; + for (int j=0;j<(m-m_stl_plus_mA11);++j) + b[j+m_stl_plus_mA11] = -S_part3x3.A12[j*ss1]; + + /// perform shifted trsv (transposed) + SerialShiftedTrsvInternalLower::invoke(m-m_stl_plus_mA11, lambda, + S_part3x3.A22, ss1, ss0, + b+m_stl_plus_mA11, 1, + blks+m_stl_plus_mA11); - /// copy back to V (row wise copy) - for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ ValueType *__restrict__ v, const int vs) { - typedef ValueType value_type; - typedef Kokkos::Details::ArithTraits ats; - typedef typename ats::mag_type mag_type; - mag_type norm(0); + /// + /// Serial Internal Impl + /// ==================== + struct SerialNormalizeInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType *__restrict__ v, const int vs) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; + + mag_type norm(0); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i::sqrt(norm); + for (int i=0;i::sqrt(norm); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ RealType *__restrict__ vr, const int vrs, - /* */ RealType *__restrict__ vi, const int vis) { - typedef RealType real_type; - typedef Kokkos::Details::ArithTraits ats; - typedef typename ats::mag_type mag_type; + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType *__restrict__ vr, const int vrs, + /* */ RealType *__restrict__ vi, const int vis) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + typedef typename ats::mag_type mag_type; - mag_type norm(0); + mag_type norm(0); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i::sqrt(norm); + for (int i=0;i::sqrt(norm); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const int k, - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * Q, const int qs0, const int qs1, - /* */ ValueType * w, - const bool is_Q_zero = false) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialQR_FormQ_Internal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const int k, + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * Q, const int qs0, const int qs1, + /* */ ValueType * w, + const bool is_Q_zero = false) { + typedef ValueType value_type; - /// Given a matrix A that includes QR factorization - /// it forms a unitary matrix Q - /// B = Q = (H0 H1 H2 H3 ... H(k-1)) I - /// where - /// A is m x k (holding H0, H1 ... H(k-1) - /// t is k x 1 - /// B is m x m - - // set identity - if (is_Q_zero) - SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); - else - SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); - - return SerialApplyQ_LeftNoTransForwardInternal - ::invoke(m, m, k, - A, as0, as1, - t, ts, - Q, qs0, qs1, - w); - } - }; - - }// end namespace Experimental + /// Given a matrix A that includes QR factorization + /// it forms a unitary matrix Q + /// B = Q = (H0 H1 H2 H3 ... H(k-1)) I + /// where + /// A is m x k (holding H0, H1 ... H(k-1) + /// t is k x 1 + /// B is m x m + + // set identity + if (is_Q_zero) + SerialSetInternal::invoke(m, value_type(1), Q, qs0+qs1); + else + SerialSetIdentityInternal::invoke(m, Q, qs0, qs1); + + return SerialApplyQ_LeftNoTransForwardInternal + ::invoke(m, m, k, + A, as0, as1, + t, ts, + Q, qs0, qs1, + w); + } + }; + } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_QR_Serial_Internal.hpp b/src/batched/KokkosBatched_QR_Serial_Internal.hpp index 2420ed2de8..a0b231b614 100644 --- a/src/batched/KokkosBatched_QR_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_QR_Serial_Internal.hpp @@ -9,71 +9,70 @@ #include "KokkosBatched_ApplyHouseholder_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialQR_Internal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, // m = NumRows(A) - const int n, // n = NumCols(A) - /* */ ValueType * A, const int as0, const int as1, - /* */ ValueType * t, const int ts, - /* */ ValueType * w) { - typedef ValueType value_type; + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialQR_Internal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, // m = NumRows(A) + const int n, // n = NumCols(A) + /* */ ValueType * A, const int as0, const int as1, + /* */ ValueType * t, const int ts, + /* */ ValueType * w) { + typedef ValueType value_type; - /// Given a matrix A, it computes QR decomposition of the matrix - /// - t is to store tau and w is for workspace + /// Given a matrix A, it computes QR decomposition of the matrix + /// - t is to store tau and w is for workspace - // partitions used for loop iteration - Partition2x2 A_part2x2(as0, as1); - Partition3x3 A_part3x3(as0, as1); + // partitions used for loop iteration + Partition2x2 A_part2x2(as0, as1); + Partition3x3 A_part3x3(as0, as1); - Partition2x1 t_part2x1(ts); - Partition3x1 t_part3x1(ts); + Partition2x1 t_part2x1(ts); + Partition3x1 t_part3x1(ts); - // initial partition of A where ATL has a zero dimension - A_part2x2.partWithATL(A, m, n, 0, 0); - t_part2x1.partWithAT (t, m, 0); + // initial partition of A where ATL has a zero dimension + A_part2x2.partWithATL(A, m, n, 0, 0); + t_part2x1.partWithAT (t, m, 0); - for (int m_atl=0;m_atl - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ ValueType * S, const int ss0, const int ss1, - /* */ ValueType * V, const int vs0, const int vs1, - /* */ ValueType * w, - const int * blks) { - typedef ValueType value_type; - typedef Kokkos::Details::ArithTraits ats; - //typedef typename ats::mag_type mag_type; - typedef Kokkos::complex complex_type; - const value_type zero(0), one(1); - //const int ss(ss0+ss1); - /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialRightEigenvectorFromSchurInternal { + /// Given a quasi upper triangular matrix S (m x m), this computes all right + /// eigenvectors. + /// + /// Parameters: + /// [in]m + /// A dimension of the square matrix S. + /// [in]S, [in]ss0, [in]ss1 + /// A quasi upper triangular part of Schur decomposition which is computed + /// A = U^H S U + /// [out]V, [in]vs0, [out]vs1 + /// A set of right eigen vectors. + /// [in]w + /// contiguous workspace that can hold complex array (m) + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType * S, const int ss0, const int ss1, + /* */ ValueType * V, const int vs0, const int vs1, + /* */ ValueType * w, + const int * blks) { + typedef ValueType value_type; + typedef Kokkos::Details::ArithTraits ats; + //typedef typename ats::mag_type mag_type; + typedef Kokkos::complex complex_type; - value_type *b = w; // consider complex case + const value_type zero(0), one(1); + //const int ss(ss0+ss1); + /// SerialSetInternal::invoke(m, m, zero, V, vs0, vs1); - /// partitions used for loop iteration - Partition2x2 S_part2x2(ss0, ss1); - Partition3x3 S_part3x3(ss0, ss1); + value_type *b = w; // consider complex case + + /// partitions used for loop iteration + Partition2x2 S_part2x2(ss0, ss1); + Partition3x3 S_part3x3(ss0, ss1); - Partition1x2 V_part1x2(vs1); - Partition1x3 V_part1x3(vs1); + Partition1x2 V_part1x2(vs1); + Partition1x3 V_part1x3(vs1); - /// initial partition of S where ABR has a zero dimension - S_part2x2.partWithABR(S, m, m, 0, 0); - V_part1x2.partWithAR(V, m, 0); + /// initial partition of S where ABR has a zero dimension + S_part2x2.partWithABR(S, m, m, 0, 0); + V_part1x2.partWithAR(V, m, 0); - //const mag_type tol = ats::epsilon(); - int m_stl = m; - for (;m_stl>0;) { - /// part 2x2 into 3x3 - const int mA11 = blks[m_stl-1]; - assert( ((mA11 == 1) || (mA11 == 2)) && "RightEigenvectorFromSchur: blk is not 1x1 nor 2x2"); + //const mag_type tol = ats::epsilon(); + int m_stl = m; + for (;m_stl>0;) { + /// part 2x2 into 3x3 + const int mA11 = blks[m_stl-1]; + assert( ((mA11 == 1) || (mA11 == 2)) && "RightEigenvectorFromSchur: blk is not 1x1 nor 2x2"); - S_part3x3.partWithATL(S_part2x2, mA11, mA11); - V_part1x3.partWithAL(V_part1x2, mA11); + S_part3x3.partWithATL(S_part2x2, mA11, mA11); + V_part1x3.partWithAL(V_part1x2, mA11); - const int m_stl_minus_mA11 = m_stl - mA11; - if (mA11 == 1) { - /// real eigenvalue - const value_type lambda = *S_part3x3.A11; + const int m_stl_minus_mA11 = m_stl - mA11; + if (mA11 == 1) { + /// real eigenvalue + const value_type lambda = *S_part3x3.A11; - /// initialize a right eigen vector - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A); - }; - - /// - /// Team Scale - /// - - template - struct TeamScale { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A); - }; - - } + + /// + /// Serial Scale + /// + + struct SerialScale { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A); + }; + + /// + /// Team Scale + /// + + template + struct TeamScale { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A); + }; + } diff --git a/src/batched/KokkosBatched_Scale_Impl.hpp b/src/batched/KokkosBatched_Scale_Impl.hpp index ea690b94cc..bc83a7b558 100644 --- a/src/batched/KokkosBatched_Scale_Impl.hpp +++ b/src/batched/KokkosBatched_Scale_Impl.hpp @@ -7,46 +7,44 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Scale_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== - template - KOKKOS_INLINE_FUNCTION - int - SerialScale:: - invoke(const ScalarType alpha, - const AViewType &A) { - return SerialScaleInternal:: - invoke(A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1()); - } - - /// - /// Team Impl - /// ========= + + /// + /// Serial Impl + /// =========== + template + KOKKOS_INLINE_FUNCTION + int + SerialScale:: + invoke(const ScalarType alpha, + const AViewType &A) { + return SerialScaleInternal:: + invoke(A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1()); + } + + /// + /// Team Impl + /// ========= - template - template - KOKKOS_INLINE_FUNCTION - int - TeamScale:: - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A) { - return TeamScaleInternal:: - invoke(member, - A.extent(0), A.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1()); - } - + template + template + KOKKOS_INLINE_FUNCTION + int + TeamScale:: + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A) { + return TeamScaleInternal:: + invoke(member, + A.extent(0), A.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1()); } + } diff --git a/src/batched/KokkosBatched_Scale_Internal.hpp b/src/batched/KokkosBatched_Scale_Internal.hpp index 756232c1ca..05c82e46c2 100644 --- a/src/batched/KokkosBatched_Scale_Internal.hpp +++ b/src/batched/KokkosBatched_Scale_Internal.hpp @@ -6,100 +6,98 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - struct SerialScaleInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0) { + + /// + /// Serial Internal Impl + /// ==================== + struct SerialScaleInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0) { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, const int n, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { - if (as0 > as1) - for (int i=0;i as1) + for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0) { + /// + /// Team Internal Impl + /// ==================== + struct TeamScaleInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0) { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,m), + [&](const int &i) { + A[i*as0] *= alpha; + }); + //member.team_barrier(); + return 0; + } + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, const int n, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + if (m > n) { Kokkos::parallel_for (Kokkos::TeamThreadRange(member,0,m), [&](const int &i) { - A[i*as0] *= alpha; + SerialScaleInternal::invoke(n, alpha, A+i*as0, as1); + }); + } else { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,n), + [&](const int &j) { + SerialScaleInternal::invoke(m, alpha, A+j*as1, as0); }); - //member.team_barrier(); - return 0; - } - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - if (m > n) { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,m), - [&](const int &i) { - SerialScaleInternal::invoke(n, alpha, A+i*as0, as1); - }); - } else { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,n), - [&](const int &j) { - SerialScaleInternal::invoke(m, alpha, A+j*as1, as0); - }); - } - //member.team_barrier(); - return 0; } - }; + //member.team_barrier(); + return 0; + } + }; - } } diff --git a/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp index ef5747910b..06f4d961aa 100644 --- a/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Schur2x2_Serial_Internal.hpp @@ -8,121 +8,120 @@ namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialSchur2x2Internal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(RealType * alpha00, RealType * alpha01, - RealType * alpha10, RealType * alpha11, - Kokkos::pair * G, - Kokkos::complex * lambda1, - Kokkos::complex * lambda2, - bool * is_complex) { - typedef RealType real_type; - typedef Kokkos::Details::ArithTraits ats; - const real_type zero(0), one(1), half(0.5), minus_one(-1); - /// compute G = [ gamma -sigma; - /// sigma gamma ]; - /// G.first = gamma and G.second = sigma - /// this rotation satisfy the following - /// G' [alpha00 alpha01 G = [ beta00 beta01; - /// alpha10 alpha11 ] beta10 beta11 ]; - /// where either - /// 1) beta00 = beta11 and beta01*beta10 < 0 - /// 2) beta10 = 0 - const real_type tol = ats::epsilon()*real_type(100); - if (ats::abs(*alpha10) < tol) { - /// no rotation - *G = Kokkos::pair(one, zero); - /// two real eigen values - *lambda1 = Kokkos::complex(*alpha00, zero); - *lambda2 = Kokkos::complex(*alpha11, zero); - *is_complex = false; - } else if (ats::abs(*alpha01) < tol) { - /// 90 degree rotation (permutation) - *G = Kokkos::pair(zero, one); - /// [ 0 1 ][alpha00 0 [ 0 -1 --> [ alpha11 -alpha10 - /// -1 0 ] alpha10 alpha11] 1 0] 0 alpha00] - const real_type tmp = *alpha00; *alpha00 = *alpha11; *alpha11 = tmp; - *alpha01 = -(*alpha10); *alpha10 = zero; - /// two real eigen values - *lambda1 = Kokkos::complex(*alpha00, zero); - *lambda2 = Kokkos::complex(*alpha11, zero); - *is_complex = false; - } else if (ats::abs(*alpha00-*alpha11) < tol && (*alpha01)*(*alpha10) > zero) { - // no rotation (already the standard schur form) - *G = Kokkos::pair(one, zero); - /// two real eigen values - *lambda1 = Kokkos::complex(*alpha00, zero); - *lambda2 = Kokkos::complex(*alpha11, zero); - *is_complex = false; - } else { - /// rotation to equalize diagonals - const real_type a = (*alpha00)-(*alpha11); - const real_type b = (*alpha01)+(*alpha10); - const real_type l = ats::sqrt(a*a+b*b); - const real_type c = ats::sqrt(half*(one+ats::abs(b)/l)); - const real_type s = -((half*a)/(l*c))*(b > zero ? one : minus_one); - *G = Kokkos::pair(c, s); - /// [ gamma sigma ][ alpha00 alpha01 [ gamma -sigma --> [ alpha11 -alpha10 - /// -sigma gamma ] alpha10 alpha11 ] sigma gamma ] 0 alpha00] - const real_type a00 = *alpha00, a01 = *alpha01; - const real_type a10 = *alpha10, a11 = *alpha11; - const real_type cc = c*c, cs = c*s, ss= s*s; - *alpha00 = cc*a00 + cs*a01 + cs*a10 + ss*a11; - *alpha01 = -cs*a00 + cc*a01 - ss*a10 + cs*a11; - *alpha10 = -cs*a00 - ss*a01 + cc*a10 + cs*a11; - *alpha11 = ss*a00 - cs*a01 - cs*a10 + cc*a11; - const real_type tmp = (*alpha00 + *alpha11)*half; - *alpha00 = tmp; - *alpha11 = tmp; + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialSchur2x2Internal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(RealType * alpha00, RealType * alpha01, + RealType * alpha10, RealType * alpha11, + Kokkos::pair * G, + Kokkos::complex * lambda1, + Kokkos::complex * lambda2, + bool * is_complex) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type zero(0), one(1), half(0.5), minus_one(-1); + /// compute G = [ gamma -sigma; + /// sigma gamma ]; + /// G.first = gamma and G.second = sigma + /// this rotation satisfy the following + /// G' [alpha00 alpha01 G = [ beta00 beta01; + /// alpha10 alpha11 ] beta10 beta11 ]; + /// where either + /// 1) beta00 = beta11 and beta01*beta10 < 0 + /// 2) beta10 = 0 + const real_type tol = ats::epsilon()*real_type(100); + if (ats::abs(*alpha10) < tol) { + /// no rotation + *G = Kokkos::pair(one, zero); + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else if (ats::abs(*alpha01) < tol) { + /// 90 degree rotation (permutation) + *G = Kokkos::pair(zero, one); + /// [ 0 1 ][alpha00 0 [ 0 -1 --> [ alpha11 -alpha10 + /// -1 0 ] alpha10 alpha11] 1 0] 0 alpha00] + const real_type tmp = *alpha00; *alpha00 = *alpha11; *alpha11 = tmp; + *alpha01 = -(*alpha10); *alpha10 = zero; + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else if (ats::abs(*alpha00-*alpha11) < tol && (*alpha01)*(*alpha10) > zero) { + // no rotation (already the standard schur form) + *G = Kokkos::pair(one, zero); + /// two real eigen values + *lambda1 = Kokkos::complex(*alpha00, zero); + *lambda2 = Kokkos::complex(*alpha11, zero); + *is_complex = false; + } else { + /// rotation to equalize diagonals + const real_type a = (*alpha00)-(*alpha11); + const real_type b = (*alpha01)+(*alpha10); + const real_type l = ats::sqrt(a*a+b*b); + const real_type c = ats::sqrt(half*(one+ats::abs(b)/l)); + const real_type s = -((half*a)/(l*c))*(b > zero ? one : minus_one); + *G = Kokkos::pair(c, s); + /// [ gamma sigma ][ alpha00 alpha01 [ gamma -sigma --> [ alpha11 -alpha10 + /// -sigma gamma ] alpha10 alpha11 ] sigma gamma ] 0 alpha00] + const real_type a00 = *alpha00, a01 = *alpha01; + const real_type a10 = *alpha10, a11 = *alpha11; + const real_type cc = c*c, cs = c*s, ss= s*s; + *alpha00 = cc*a00 + cs*a01 + cs*a10 + ss*a11; + *alpha01 = -cs*a00 + cc*a01 - ss*a10 + cs*a11; + *alpha10 = -cs*a00 - ss*a01 + cc*a10 + cs*a11; + *alpha11 = ss*a00 - cs*a01 - cs*a10 + cc*a11; - const real_type mult_alpha_offdiags = (*alpha10)*(*alpha01); - if (mult_alpha_offdiags > zero) { - /// transforms the matrix into a upper triangular - const real_type sqrt_mult_alpha_offdiags = ats::sqrt(mult_alpha_offdiags); + const real_type tmp = (*alpha00 + *alpha11)*half; + *alpha00 = tmp; + *alpha11 = tmp; - /// redefine the rotation matrix - //const real_type sqrt_abs_alpha01 = ats::sqrt(ats::abs(*alpha01)); - //const real_type sqrt_abs_alpha10 = ats::sqrt(ats::abs(*alpha10)); - const real_type abs_sum_offidags = ats::abs((*alpha01)+(*alpha10)); - const real_type c1 = ats::sqrt(ats::abs(*alpha01)/abs_sum_offidags); - const real_type s1 = ats::sqrt(ats::abs(*alpha10)/abs_sum_offidags); - const real_type sign_alpha10 = *alpha10 > zero ? one : minus_one; + const real_type mult_alpha_offdiags = (*alpha10)*(*alpha01); + if (mult_alpha_offdiags > zero) { + /// transforms the matrix into a upper triangular + const real_type sqrt_mult_alpha_offdiags = ats::sqrt(mult_alpha_offdiags); - *G = Kokkos::pair(c*c1-s*s1,c*s1+s*c1); + /// redefine the rotation matrix + //const real_type sqrt_abs_alpha01 = ats::sqrt(ats::abs(*alpha01)); + //const real_type sqrt_abs_alpha10 = ats::sqrt(ats::abs(*alpha10)); + const real_type abs_sum_offidags = ats::abs((*alpha01)+(*alpha10)); + const real_type c1 = ats::sqrt(ats::abs(*alpha01)/abs_sum_offidags); + const real_type s1 = ats::sqrt(ats::abs(*alpha10)/abs_sum_offidags); + const real_type sign_alpha10 = *alpha10 > zero ? one : minus_one; - /// apply rotation to 2x2 matrix so that alpha10 becomes zero - *alpha00 = tmp + sign_alpha10*sqrt_mult_alpha_offdiags; - *alpha11 = tmp - sign_alpha10*sqrt_mult_alpha_offdiags; - *alpha01 = (*alpha01)-(*alpha10); - *alpha10 = zero; + *G = Kokkos::pair(c*c1-s*s1,c*s1+s*c1); - // two real eigen values - *lambda1 = Kokkos::complex(*alpha00); - *lambda2 = Kokkos::complex(*alpha11); - *is_complex = false; - } else { - /// two complex eigen values - const real_type sqrt_mult_alpha_offdiags = ats::sqrt(-mult_alpha_offdiags); - *lambda1 = Kokkos::complex(tmp, sqrt_mult_alpha_offdiags); - *lambda2 = Kokkos::complex(lambda1->real(), -lambda1->imag()); - *is_complex = true; - } + /// apply rotation to 2x2 matrix so that alpha10 becomes zero + *alpha00 = tmp + sign_alpha10*sqrt_mult_alpha_offdiags; + *alpha11 = tmp - sign_alpha10*sqrt_mult_alpha_offdiags; + *alpha01 = (*alpha01)-(*alpha10); + *alpha10 = zero; + + // two real eigen values + *lambda1 = Kokkos::complex(*alpha00); + *lambda2 = Kokkos::complex(*alpha11); + *is_complex = false; + } else { + /// two complex eigen values + const real_type sqrt_mult_alpha_offdiags = ats::sqrt(-mult_alpha_offdiags); + *lambda1 = Kokkos::complex(tmp, sqrt_mult_alpha_offdiags); + *lambda2 = Kokkos::complex(lambda1->real(), -lambda1->imag()); + *is_complex = true; } - return 0; } - }; + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp index a4a4aadbf0..c66d00ddd6 100644 --- a/src/batched/KokkosBatched_Schur_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Schur_Serial_Internal.hpp @@ -12,156 +12,213 @@ #include "KokkosBatched_Francis_Serial_Internal.hpp" namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialSchurInternal { - /// Given a strictly Hessenberg matrix H (m x m), this computes schur decomposition - /// using the Francis method and stores them into a vector e. This routine does - /// not scale nor balance the matrix for the numerical stability. - /// H = Z T Z^H and T = Z^H H Z - /// Parameters: - /// [in]m - /// A dimension of the square matrix H. - /// [in/out]H, [in]hs0, [in]hs1 - /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. - /// Entering the routine, H is assumed to have a upper Hessenberg form, where - /// all subdiagonals are zero. The matrix is overwritten as a upper triangular T - /// on exit. - /// [in/out]Z, [in]zs0, [in]zs1 - /// Unitary matrix resulting from Schur decomposition. With a restarting option, - /// the matrix may contain previous partial computation results. - /// [in/out]w, [in]wlen - /// Contiguous workspace of which size is wlen. When restart is true, this - /// workspace is not corrupted after the previous iteration. Temporarily, it stores - /// subdiag values and given rotations. wlen should be at least 3*m. - /// [in]restart(false) - /// With a restart option, the routine assume that the matrix H and the vector e - /// contain the partial results from the previous run. When m = 1 or 2, this option - /// won't work as the routine always computes the all eigenvalues. - /// [in]user_max_iteration(300) - /// Unlike LAPACK which uses various methods for different types of matrices, - /// this routine uses the Francis method only. A user can set the maximum number - /// of iterations. When it reaches the maximum iteration counts without converging - /// all eigenvalues, the routine returns -1. - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ RealType * H, const int hs0, const int hs1, - /* */ RealType * Z, const int zs0, const int zs1, - /* */ RealType * w, const int wlen, - const bool restart = false, - const int user_max_iteration = -1) { - typedef RealType real_type; - typedef Kokkos::Details::ArithTraits ats; - const real_type /* one(1), */zero(0), tol = 1e2*ats::epsilon(); - const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; - if (wlen < m*5) - Kokkos::abort("Error: provided workspace is smaller than 3*m"); - int r_val = 0; - if (restart) { - if (m <= 2) - Kokkos::abort("Error: restart option cannot be used for m=1 or m=2"); - } else { - /// do not touch input - /// SerialSetIdentityInternal::invoke(m, Z, zs0, zs1); - } + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialSchurInternal { + /// Given a strictly Hessenberg matrix H (m x m), this computes schur decomposition + /// using the Francis method and stores them into a vector e. This routine does + /// not scale nor balance the matrix for the numerical stability. + /// H = Z T Z^H and T = Z^H H Z + /// Parameters: + /// [in]m + /// A dimension of the square matrix H. + /// [in/out]H, [in]hs0, [in]hs1 + /// Real Hessenberg matrix H(m x m) with strides hs0 and hs1. + /// Entering the routine, H is assumed to have a upper Hessenberg form, where + /// all subdiagonals are zero. The matrix is overwritten as a upper triangular T + /// on exit. + /// [in/out]Z, [in]zs0, [in]zs1 + /// Unitary matrix resulting from Schur decomposition. With a restarting option, + /// the matrix may contain previous partial computation results. + /// [in/out]w, [in]wlen + /// Contiguous workspace of which size is wlen. When restart is true, this + /// workspace is not corrupted after the previous iteration. Temporarily, it stores + /// subdiag values and given rotations. wlen should be at least 3*m. + /// [in]restart(false) + /// With a restart option, the routine assume that the matrix H and the vector e + /// contain the partial results from the previous run. When m = 1 or 2, this option + /// won't work as the routine always computes the all eigenvalues. + /// [in]user_max_iteration(300) + /// Unlike LAPACK which uses various methods for different types of matrices, + /// this routine uses the Francis method only. A user can set the maximum number + /// of iterations. When it reaches the maximum iteration counts without converging + /// all eigenvalues, the routine returns -1. + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ RealType * H, const int hs0, const int hs1, + /* */ RealType * Z, const int zs0, const int zs1, + /* */ RealType * w, const int wlen, + const bool restart = false, + const int user_max_iteration = -1) { + typedef RealType real_type; + typedef Kokkos::Details::ArithTraits ats; + const real_type /* one(1), */zero(0), tol = 1e2*ats::epsilon(); + const int max_iteration = user_max_iteration < 0 ? 300 : user_max_iteration; + if (wlen < m*5) + Kokkos::abort("Error: provided workspace is smaller than 3*m"); - // workspaces - real_type *subdiags = w; - Kokkos::pair *Gs = (Kokkos::pair*)(w+m); - if (!restart) { - /// initialize workspace and Gs - for (int i=0;i lambda1, lambda2; - Kokkos::pair G; - SerialSchur2x2Internal::invoke(H, H+hs1, - H+hs0, H+hs, - &G, - &lambda1, &lambda2, - &is_complex); + // workspaces + real_type *subdiags = w; + Kokkos::pair *Gs = (Kokkos::pair*)(w+m); + if (!restart) { + /// initialize workspace and Gs + for (int i=0;i lambda1, lambda2; + Kokkos::pair G; + SerialSchur2x2Internal::invoke(H, H+hs1, + H+hs0, H+hs, + &G, + &lambda1, &lambda2, + &is_complex); - while (!converge && iter < max_iteration) { - /// Step 1: find a set of unrevealed eigenvalues - int cnt = 1; + G.second = -G.second; // transpose + SerialApplyRightGivensInternal::invoke(G, 2, + Z, zs0, + Z+zs1, zs0); + break; + } + default: { + /// Francis method + int iter(0); /// iteration count + bool converge = false; /// bool to check all eigenvalues are converged + + while (!converge && iter < max_iteration) { + /// Step 1: find a set of unrevealed eigenvalues + int cnt = 1; - /// find mbeg (first nonzero subdiag value) - for (;cnt tol) break; - } - const int mbeg = cnt-1; + /// find mbeg (first nonzero subdiag value) + for (;cnt tol) break; + } + const int mbeg = cnt-1; - /// find mend (first zero subdiag value) - for (;cnt G(Gs[i].first, -Gs[i].second); - SerialApplyRightGivensInternal::invoke(G, m, - Z+i*zs1, zs0, - Z+i*zs1+zs1, zs0); - } + for (int i=mbeg;i<(mend-1);++i) { + const Kokkos::pair G(Gs[i].first, -Gs[i].second); + SerialApplyRightGivensInternal::invoke(G, m, + Z+i*zs1, zs0, + Z+i*zs1+zs1, zs0); } + } # endif # if 1 - { - /// find a complex eigen pair - Kokkos::complex lambda1, lambda2; - bool is_complex; - real_type *sub2x2 = H+(mend-2)*hs; - if (2 == mdiff) { + { + /// find a complex eigen pair + Kokkos::complex lambda1, lambda2; + bool is_complex; + real_type *sub2x2 = H+(mend-2)*hs; + if (2 == mdiff) { + Kokkos::pair G; + SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, + sub2x2+hs0, sub2x2+hs, + &G, + &lambda1, &lambda2, + &is_complex); + subdiags[mend-1] = sub2x2[hs0]; + + /// apply G' from left + G.second = -G.second; + SerialApplyLeftGivensInternal::invoke (G, m-mend, + sub2x2 +2*hs1, hs1, + sub2x2+hs0+2*hs1, hs1); + + /// apply (G')' from right + SerialApplyRightGivensInternal::invoke(G, mend-2, + sub2x2 -mend_minus_two_mult_hs0, hs0, + sub2x2+hs1-mend_minus_two_mult_hs0, hs0); + sub2x2[hs0] = zero; + + /// apply (G')' from right to compute Z + SerialApplyRightGivensInternal::invoke(G, m, + Z+(mend-2)*zs1, zs0, + Z+(mend-1)*zs1, zs0); + + } else { + SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], + sub2x2[hs0], sub2x2[hs], + &lambda1, &lambda2, + &is_complex); + + SerialFrancisInternal::invoke(mbeg, mend, m, + H, hs0, hs1, + lambda1, lambda2, + is_complex, + Gs, true); + /* */ auto &val1 = *(sub2x2+hs0); + /* */ auto &val2 = *(sub2x2-hs1); + const auto abs_val1 = ats::abs(val1); + const auto abs_val2 = ats::abs(val2); + + for (int i=mbeg;i<(mend-1);++i) { + const Kokkos::pair G0(Gs[2*i ].first, -Gs[2*i ].second); + const Kokkos::pair G1(Gs[2*i+1].first, -Gs[2*i+1].second); + SerialApplyRightGivensInternal::invoke(G0, m, + Z+i*zs1, zs0, + Z+i*zs1+1*zs1, zs0); + SerialApplyRightGivensInternal::invoke(G1, m, + Z+i*zs1, zs0, + Z+i*zs1+2*zs1, zs0); + } + + /// convergence check + if (abs_val1 < tol) { + val1 = zero; + } else if (abs_val2 < tol) { + /// preserve the standard schur form Kokkos::pair G; SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, sub2x2+hs0, sub2x2+hs, &G, &lambda1, &lambda2, &is_complex); - subdiags[mend-1] = sub2x2[hs0]; + subdiags[mend-1] = val1; /// apply G' from left G.second = -G.second; @@ -169,105 +226,46 @@ namespace KokkosBatched { sub2x2 +2*hs1, hs1, sub2x2+hs0+2*hs1, hs1); - /// apply (G')' from right + // apply (G')' from right SerialApplyRightGivensInternal::invoke(G, mend-2, sub2x2 -mend_minus_two_mult_hs0, hs0, sub2x2+hs1-mend_minus_two_mult_hs0, hs0); - sub2x2[hs0] = zero; + val1 = zero; + val2 = zero; - /// apply (G')' from right to compute Z + // apply (G')' from right SerialApplyRightGivensInternal::invoke(G, m, - Z+(mend-2)*zs1, zs0, + Z+(mend-2)*zs1, zs0, Z+(mend-1)*zs1, zs0); - - } else { - SerialWilkinsonShiftInternal::invoke(sub2x2[0], sub2x2[hs1], - sub2x2[hs0], sub2x2[hs], - &lambda1, &lambda2, - &is_complex); - - SerialFrancisInternal::invoke(mbeg, mend, m, - H, hs0, hs1, - lambda1, lambda2, - is_complex, - Gs, true); - /* */ auto &val1 = *(sub2x2+hs0); - /* */ auto &val2 = *(sub2x2-hs1); - const auto abs_val1 = ats::abs(val1); - const auto abs_val2 = ats::abs(val2); - - for (int i=mbeg;i<(mend-1);++i) { - const Kokkos::pair G0(Gs[2*i ].first, -Gs[2*i ].second); - const Kokkos::pair G1(Gs[2*i+1].first, -Gs[2*i+1].second); - SerialApplyRightGivensInternal::invoke(G0, m, - Z+i*zs1, zs0, - Z+i*zs1+1*zs1, zs0); - SerialApplyRightGivensInternal::invoke(G1, m, - Z+i*zs1, zs0, - Z+i*zs1+2*zs1, zs0); - } - - /// convergence check - if (abs_val1 < tol) { - val1 = zero; - } else if (abs_val2 < tol) { - /// preserve the standard schur form - Kokkos::pair G; - SerialSchur2x2Internal::invoke(sub2x2, sub2x2+hs1, - sub2x2+hs0, sub2x2+hs, - &G, - &lambda1, &lambda2, - &is_complex); - subdiags[mend-1] = val1; - - /// apply G' from left - G.second = -G.second; - SerialApplyLeftGivensInternal::invoke (G, m-mend, - sub2x2 +2*hs1, hs1, - sub2x2+hs0+2*hs1, hs1); - - // apply (G')' from right - SerialApplyRightGivensInternal::invoke(G, mend-2, - sub2x2 -mend_minus_two_mult_hs0, hs0, - sub2x2+hs1-mend_minus_two_mult_hs0, hs0); - val1 = zero; - val2 = zero; - - // apply (G')' from right - SerialApplyRightGivensInternal::invoke(G, m, - Z+(mend-2)*zs1, zs0, - Z+(mend-1)*zs1, zs0); - } } } -# endif - } else { - /// all eigenvalues are converged - converge = true; - } - ++iter; - } - /// Step 3: record missing real eigenvalues from the diagonals - if (converge) { - // recover subdiags - real_type *Hs = H-hs1; - for (int i=1;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A); - }; - - /// - /// Team Set - /// - - template - struct TeamSetIdentity { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A); - }; - - - /// - /// Selective Interface - /// - template - struct SetIdentity { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialSetIdentity::invoke(A); - } else if (std::is_same::value) { - r_val = TeamSetIdentity::invoke(member, A); - } - return r_val; - } - }; - - } + + /// + /// Serial SetIdentity + /// + + struct SerialSetIdentity { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A); + }; + + /// + /// Team Set + /// + + template + struct TeamSetIdentity { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A); + }; + + + /// + /// Selective Interface + /// + template + struct SetIdentity { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialSetIdentity::invoke(A); + } else if (std::is_same::value) { + r_val = TeamSetIdentity::invoke(member, A); + } + return r_val; + } + }; + } + #endif diff --git a/src/batched/KokkosBatched_SetIdentity_Impl.hpp b/src/batched/KokkosBatched_SetIdentity_Impl.hpp index 4cd7da82da..4c0ea12348 100644 --- a/src/batched/KokkosBatched_SetIdentity_Impl.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Impl.hpp @@ -7,41 +7,39 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_SetIdentity_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== + + /// + /// Serial Impl + /// =========== - template - KOKKOS_INLINE_FUNCTION - int - SerialSetIdentity:: - invoke(const AViewType &A) { - return SerialSetIdentityInternal:: - invoke(A.extent(0), - A.data(), A.stride_0(), A.stride_1()); - } - - /// - /// Team Impl - /// ========= + template + KOKKOS_INLINE_FUNCTION + int + SerialSetIdentity:: + invoke(const AViewType &A) { + return SerialSetIdentityInternal:: + invoke(A.extent(0), + A.data(), A.stride_0(), A.stride_1()); + } + + /// + /// Team Impl + /// ========= - template - template - KOKKOS_INLINE_FUNCTION - int - TeamSetIdentity:: - invoke(const MemberType &member, - const AViewType &A) { - return TeamSetIdentityInternal:: - invoke(member, - A.extent(0), - A.data(), A.stride_0(), A.stride_1()); - } + template + template + KOKKOS_INLINE_FUNCTION + int + TeamSetIdentity:: + invoke(const MemberType &member, + const AViewType &A) { + return TeamSetIdentityInternal:: + invoke(member, + A.extent(0), + A.data(), A.stride_0(), A.stride_1()); + } - } // end namespace Experimental } //end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_SetIdentity_Internal.hpp b/src/batched/KokkosBatched_SetIdentity_Internal.hpp index 1c4e653b31..0604a6d009 100644 --- a/src/batched/KokkosBatched_SetIdentity_Internal.hpp +++ b/src/batched/KokkosBatched_SetIdentity_Internal.hpp @@ -6,59 +6,57 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - struct SerialSetIdentityInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - const ValueType one(1), zero(0); - for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + const ValueType one(1), zero(0); + for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - const ValueType one(1), zero(0); - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,m), - [&](const int &i) { + + return 0; + } + }; + + /// + /// Team Internal Impl + /// ================== + struct TeamSetIdentityInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + const ValueType one(1), zero(0); + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,m), + [&](const int &i) { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, - const int dist, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - for (int j=0;j + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, const int n, + const int dist, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + for (int j=0;j - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A); - }; - - /// - /// Team Set - /// - - template - struct TeamSet { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A); - }; - - } + /// + /// Serial Set + /// + + struct SerialSet { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A); + }; + + /// + /// Team Set + /// + + template + struct TeamSet { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A); + }; + } diff --git a/src/batched/KokkosBatched_Set_Impl.hpp b/src/batched/KokkosBatched_Set_Impl.hpp index 7184a502e6..8aeebb908c 100644 --- a/src/batched/KokkosBatched_Set_Impl.hpp +++ b/src/batched/KokkosBatched_Set_Impl.hpp @@ -7,9 +7,8 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Set_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { + /// /// Serial Impl /// =========== @@ -46,8 +45,6 @@ namespace KokkosBatched { alpha, A.data(), A.stride_0(), A.stride_1()); } - - } // end namespace Experimental } //end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Set_Internal.hpp b/src/batched/KokkosBatched_Set_Internal.hpp index 7bd74e9d91..ebed3da486 100644 --- a/src/batched/KokkosBatched_Set_Internal.hpp +++ b/src/batched/KokkosBatched_Set_Internal.hpp @@ -6,99 +6,97 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - struct SerialSetInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0) { + + /// + /// Serial Internal Impl + /// ==================== + struct SerialSetInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0) { #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, const int n, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - if (as0 > as1) - for (int i=0;i + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, const int n, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + if (as0 > as1) + for (int i=0;i - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0) { + /// + /// Team Internal Impl + /// ================== + struct TeamSetInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0) { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,m), + [&](const int &i) { + A[i*as0] = alpha; + }); + //member.team_barrier(); + return 0; + } + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const int m, const int n, + const ScalarType alpha, + /* */ ValueType *__restrict__ A, const int as0, const int as1) { + if (m > n) { Kokkos::parallel_for (Kokkos::TeamThreadRange(member,0,m), [&](const int &i) { - A[i*as0] = alpha; + SerialSetInternal::invoke(n, alpha, A+i*as0, as1); + }); + } else { + Kokkos::parallel_for + (Kokkos::TeamThreadRange(member,0,n), + [&](const int &j) { + SerialSetInternal::invoke(m, alpha, A+j*as1, as0); }); - //member.team_barrier(); - return 0; - } - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const int m, const int n, - const ScalarType alpha, - /* */ ValueType *__restrict__ A, const int as0, const int as1) { - if (m > n) { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,m), - [&](const int &i) { - SerialSetInternal::invoke(n, alpha, A+i*as0, as1); - }); - } else { - Kokkos::parallel_for - (Kokkos::TeamThreadRange(member,0,n), - [&](const int &j) { - SerialSetInternal::invoke(m, alpha, A+j*as1, as0); - }); - } - //member.team_barrier(); - return 0; } - }; + //member.team_barrier(); + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_ShiftedTrsv_Serial_Internal.hpp b/src/batched/KokkosBatched_ShiftedTrsv_Serial_Internal.hpp index 4086fa8917..3cf1c774c5 100644 --- a/src/batched/KokkosBatched_ShiftedTrsv_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_ShiftedTrsv_Serial_Internal.hpp @@ -12,147 +12,145 @@ #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" #include "KokkosBatched_Gemv_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Internal Impl - /// ==================== - - /// - /// Lower - /// - - struct SerialShiftedTrsvInternalLower { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const ScalarType lambda, - const ValueTypeA *__restrict__ A, const int as0, const int as1, - /* */ ValueTypeB *__restrict__ b, const int bs0, - const int *__restrict__ blks) { - const int as = as0+as1; - - int p = 0; - for (;p + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType lambda, + const ValueTypeA *__restrict__ A, const int as0, const int as1, + /* */ ValueTypeB *__restrict__ b, const int bs0, + const int *__restrict__ blks) { + const int as = as0+as1; + + int p = 0; + for (;p - KOKKOS_INLINE_FUNCTION - static int - invoke(const int m, - const ScalarType lambda, - const ValueTypeA *__restrict__ A, const int as0, const int as1, - /**/ ValueTypeB *__restrict__ b, const int bs0, - const int *__restrict__ blks) { - const int as = as0+as1; - - ValueTypeB *__restrict__ b0 = b; + struct SerialShiftedTrsvInternalUpper { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const int m, + const ScalarType lambda, + const ValueTypeA *__restrict__ A, const int as0, const int as1, + /**/ ValueTypeB *__restrict__ b, const int bs0, + const int *__restrict__ blks) { + const int as = as0+as1; + + ValueTypeB *__restrict__ b0 = b; - int p = m-1; - for (;p>=0;) { - const int blk = blks[p], iend = p+1-blk; - assert( ((blk == 1) || (blk == 2)) && "ShiftedTrsvUpper: blocks are not 1x1 or 2x2"); - if (blk == 1) { - const auto alpha11 = A[p*as]-lambda; - /**/ ValueTypeB *__restrict__ beta1 = b+p*bs0; - - // with __restrict__ a compiler assumes that the pointer is not accessed by others - // op(/=) uses this pointer and changes the associated values, which brings a compiler problem - *beta1 = *beta1 / alpha11; - - if (iend) { - const ValueTypeA *__restrict__ a01 = A+p*as1; - for (int i=0;i=0;) { + const int blk = blks[p], iend = p+1-blk; + assert( ((blk == 1) || (blk == 2)) && "ShiftedTrsvUpper: blocks are not 1x1 or 2x2"); + if (blk == 1) { + const auto alpha11 = A[p*as]-lambda; + /**/ ValueTypeB *__restrict__ beta1 = b+p*bs0; + + // with __restrict__ a compiler assumes that the pointer is not accessed by others + // op(/=) uses this pointer and changes the associated values, which brings a compiler problem + *beta1 = *beta1 / alpha11; + + if (iend) { + const ValueTypeA *__restrict__ a01 = A+p*as1; + for (int i=0;i - struct SerialSolveLU { - // no piv version - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const AViewType &A, - const BViewType &B) { - int r_val[2] = {}; - const typename AViewType::non_const_value_type one(1.0); - if (std::is_same::value) { - //First, compute Y (= U*X) by solving the system L*Y = B for Y - r_val[0] = SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system U*X = Y for X - r_val[1] = SerialTrsm::invoke(one, A, B); - } else if (std::is_same::value || - std::is_same::value) { - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - r_val[0] = SerialTrsm::invoke(one, A, B); - //Second, compute X by solving the system L'*X = Y for X - r_val[1] = SerialTrsm::invoke(one, A, B); - } - return r_val[0]+r_val[1]; + template + struct SerialSolveLU { + // no piv version + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const AViewType &A, + const BViewType &B) { + int r_val[2] = {}; + const typename AViewType::non_const_value_type one(1.0); + if (std::is_same::value) { + //First, compute Y (= U*X) by solving the system L*Y = B for Y + r_val[0] = SerialTrsm::invoke(one, A, B); + //Second, compute X by solving the system U*X = Y for X + r_val[1] = SerialTrsm::invoke(one, A, B); + } else if (std::is_same::value || + std::is_same::value) { + //First, compute Y (= L'*X) by solving the system U'*Y = B for Y + r_val[0] = SerialTrsm::invoke(one, A, B); + //Second, compute X by solving the system L'*X = Y for X + r_val[1] = SerialTrsm::invoke(one, A, B); } - }; + return r_val[0]+r_val[1]; + } + }; - template - struct TeamSolveLU { - // no piv version - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const BViewType &B) { - int r_val[2] = {}; - const typename AViewType::non_const_value_type one(1.0); - if (std::is_same::value) { - //First, compute Y (= U*X) by solving the system L*Y = B for Y - r_val[0] = TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system U*X = Y for X - r_val[1] = TeamTrsm::invoke(member, one, A, B); - } else if (std::is_same::value || - std::is_same::value) { - //First, compute Y (= L'*X) by solving the system U'*Y = B for Y - r_val[0] = TeamTrsm::invoke(member, one, A, B); - //Second, compute X by solving the system L'*X = Y for X - r_val[1] = TeamTrsm::invoke(member, one, A, B); - } - return r_val[0]+r_val[1]; + template + struct TeamSolveLU { + // no piv version + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B) { + int r_val[2] = {}; + const typename AViewType::non_const_value_type one(1.0); + if (std::is_same::value) { + //First, compute Y (= U*X) by solving the system L*Y = B for Y + r_val[0] = TeamTrsm::invoke(member, one, A, B); + //Second, compute X by solving the system U*X = Y for X + r_val[1] = TeamTrsm::invoke(member, one, A, B); + } else if (std::is_same::value || + std::is_same::value) { + //First, compute Y (= L'*X) by solving the system U'*Y = B for Y + r_val[0] = TeamTrsm::invoke(member, one, A, B); + //Second, compute X by solving the system L'*X = Y for X + r_val[1] = TeamTrsm::invoke(member, one, A, B); } - }; + return r_val[0]+r_val[1]; + } + }; - /// - /// Selective Interface - /// - template - struct SolveLU { - // no piv version - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const AViewType &A, - const BViewType &B) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialSolveLU::invoke(A, B); - } else if (std::is_same::value) { - r_val = TeamSolveLU::invoke(member, A, B); - } - return r_val; - } - }; + /// + /// Selective Interface + /// + template + struct SolveLU { + // no piv version + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialSolveLU::invoke(A, B); + } else if (std::is_same::value) { + r_val = TeamSolveLU::invoke(member, A, B); + } + return r_val; + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Test_BlockCrs_Util.hpp b/src/batched/KokkosBatched_Test_BlockCrs_Util.hpp index 3a8f61daba..00df6be312 100644 --- a/src/batched/KokkosBatched_Test_BlockCrs_Util.hpp +++ b/src/batched/KokkosBatched_Test_BlockCrs_Util.hpp @@ -16,7 +16,6 @@ } namespace KokkosBatched { - using namespace Experimental; namespace Test { @@ -909,12 +908,5 @@ namespace KokkosBatched { } }; - - - - - - - } } diff --git a/src/batched/KokkosBatched_Trsm_Decl.hpp b/src/batched/KokkosBatched_Trsm_Decl.hpp index 24f39dc6c2..fb92b66080 100644 --- a/src/batched/KokkosBatched_Trsm_Decl.hpp +++ b/src/batched/KokkosBatched_Trsm_Decl.hpp @@ -7,74 +7,72 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" - namespace KokkosBatched { - namespace Experimental { - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B); - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B); + }; - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B); - }; + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B); + }; - /// - /// Selective Interface - /// - template - struct Trsm { - template - KOKKOS_FORCEINLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialTrsm::invoke(alpha, A, B); - } else if (std::is_same::value) { - r_val = TeamTrsm::invoke(member, alpha, A, B); - } - return r_val; - } - }; + /// + /// Selective Interface + /// + template + struct Trsm { + template + KOKKOS_FORCEINLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialTrsm::invoke(alpha, A, B); + } else if (std::is_same::value) { + r_val = TeamTrsm::invoke(member, alpha, A, B); + } + return r_val; + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Trsm_Serial_Impl.hpp b/src/batched/KokkosBatched_Trsm_Serial_Impl.hpp index d08983d45b..e131df195b 100644 --- a/src/batched/KokkosBatched_Trsm_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Trsm_Serial_Impl.hpp @@ -7,487 +7,485 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Trsm_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// L/L/NT - /// - /// B := inv(tril(A)) (alpha*B) - /// A(m x m), B(m x n) + /// + /// L/L/NT + /// + /// B := inv(tril(A)) (alpha*B) + /// A(m x m), B(m x n) #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - typedef typename BViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + typedef typename BViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = B.dimension(0), - n = B.dimension(1); + const int + m = B.dimension(0), + n = B.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_1(), - (double*)B.data(), B.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)B.data(), B.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_1(), + (double*)B.data(), B.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)B.data(), B.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - /// - /// R/U/NT - /// - /// B := (alpha*B) inv(triu(A)) - /// A(n x n), B(m x n) + /// + /// R/U/NT + /// + /// B := (alpha*B) inv(triu(A)) + /// A(n x n), B(m x n) #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - typedef typename BViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + typedef typename BViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = B.dimension(0), - n = B.dimension(1); + const int + m = B.dimension(0), + n = B.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_RIGHT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_1(), - (double*)B.data(), B.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_RIGHT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)B.data(), B.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_RIGHT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_1(), + (double*)B.data(), B.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_RIGHT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)B.data(), B.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, - B.extent(1), B.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0()); - } - }; - - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, B.extent(1), B.extent(0), alpha, A.data(), A.stride_1(), A.stride_0(), B.data(), B.stride_1(), B.stride_0()); - } - }; + } + }; + + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + B.extent(1), B.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0()); + } + }; - /// - /// L/U/NT - /// - /// B := inv(triu(A)) (alpha*B) - /// A(m x m), B(m x n) + /// + /// L/U/NT + /// + /// B := inv(triu(A)) (alpha*B) + /// A(m x m), B(m x n) #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - typedef typename BViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + typedef typename BViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = B.dimension(0), - n = B.dimension(1); + const int + m = B.dimension(0), + n = B.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_1(), - (double*)B.data(), B.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)B.data(), B.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_1(), + (double*)B.data(), B.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)B.data(), B.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - /// - /// L/L/T - /// - /// B := inv(tril(AT)) (alpha*B) - /// A(m x m), B(m x n) + /// + /// L/L/T + /// + /// B := inv(tril(AT)) (alpha*B) + /// A(m x m), B(m x n) #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - typedef typename BViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + typedef typename BViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = B.dimension(0), - n = B.dimension(1); + const int + m = B.dimension(0), + n = B.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_1(), - (double*)B.data(), B.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)B.data(), B.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_1(), + (double*)B.data(), B.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)B.data(), B.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - /// - /// L/U/NT - /// - /// B := inv(triu(AT)) (alpha*B) - /// A(m x m), B(m x n) + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftLower::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; + /// + /// L/U/NT + /// + /// B := inv(triu(AT)) (alpha*B) + /// A(m x m), B(m x n) #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - typedef typename BViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + typedef typename BViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = B.dimension(0), - n = B.dimension(1); + const int + m = B.dimension(0), + n = B.dimension(1); - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1 && B.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_1(), - (double*)B.data(), B.stride_1(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1 && B.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)B.data(), B.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1 && B.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_1(), + (double*)B.data(), B.stride_1(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1 && B.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)B.data(), B.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - template - struct SerialTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; + template + struct SerialTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return SerialTrsmInternalLeftUpper::invoke(ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Trsm_Serial_Internal.hpp b/src/batched/KokkosBatched_Trsm_Serial_Internal.hpp index eb9ca3a3eb..9317d775b0 100644 --- a/src/batched/KokkosBatched_Trsm_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Trsm_Serial_Internal.hpp @@ -12,265 +12,264 @@ #include "KokkosBatched_InnerGemmFixA_Serial_Impl.hpp" #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - template - struct SerialTrsmInternalLeftLower { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1); - }; + /// + /// Serial Internal Impl + /// ==================== - template<> + template + struct SerialTrsmInternalLeftLower { template KOKKOS_INLINE_FUNCTION - int - SerialTrsmInternalLeftLower:: + static int invoke(const bool use_unit_diag, - const int m, const int n, + const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + /**/ ValueType *__restrict__ B, const int bs0, const int bs1); + }; - const ScalarType one(1.0), zero(0.0); + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsmInternalLeftLower:: + invoke(const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + + const ScalarType one(1.0), zero(0.0); - if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); - else { - if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); + else { + if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - SerialTrsmInternalLeftLower:: - invoke(const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsmInternalLeftLower:: + invoke(const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); - else { - if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); + else { + if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, bs1); - InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, bs1); + InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, bs1); + InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, bs1); - InnerGemmFixA gemm(as0, as1, bs0, bs1, bs0, bs1); - auto trsm = [&](const int ib, - const int jb, - const ValueType *__restrict__ AA, - /**/ ValueType *__restrict__ BB) { - const int mb = mbAlgo; - for (int p=0;p ib ? (ib-p) : mb; + InnerGemmFixA gemm(as0, as1, bs0, bs1, bs0, bs1); + auto trsm = [&](const int ib, + const int jb, + const ValueType *__restrict__ AA, + /**/ ValueType *__restrict__ BB) { + const int mb = mbAlgo; + for (int p=0;p ib ? (ib-p) : mb; - // trsm update - const ValueType *__restrict__ Ap = AA+p*as0+p*as1; - /**/ ValueType *__restrict__ Bp = BB+p*bs0; + // trsm update + const ValueType *__restrict__ Ap = AA+p*as0+p*as1; + /**/ ValueType *__restrict__ Bp = BB+p*bs0; - if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, jb, Bp); - else trsm_n.serial_invoke(Ap, pb, jb, Bp); + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, jb, Bp); + else trsm_n.serial_invoke(Ap, pb, jb, Bp); - // gemm update - for (int i=p+mb;i ib ? (ib-i) : mb; - gemm.serial_invoke(minus_one, AA+i*as0+p*as1, BB+p*bs0, mm, jb, pb, BB+i*bs0); - } + // gemm update + for (int i=p+mb;i ib ? (ib-i) : mb; + gemm.serial_invoke(minus_one, AA+i*as0+p*as1, BB+p*bs0, mm, jb, pb, BB+i*bs0); } - }; - - const bool is_small = true; //(m*n <= 64*64); - if (is_small) { - trsm(m, n, A, B); - } else { - // // some cache blocking may need (not priority yet); - // trsm(m, n, A, B); } + }; + + const bool is_small = true; //(m*n <= 64*64); + if (is_small) { + trsm(m, n, A, B); + } else { + // // some cache blocking may need (not priority yet); + // trsm(m, n, A, B); } - return 0; } + return 0; + } - template - struct SerialTrsmInternalLeftUpper { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1); - }; - - template<> + template + struct SerialTrsmInternalLeftUpper { template KOKKOS_INLINE_FUNCTION - int - SerialTrsmInternalLeftUpper:: + static int invoke(const bool use_unit_diag, - const int m, const int n, + const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + /**/ ValueType *__restrict__ B, const int bs0, const int bs1); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsmInternalLeftUpper:: + invoke(const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - const ScalarType one(1.0), zero(0.0); + const ScalarType one(1.0), zero(0.0); - if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); - else { - if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); + else { + if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - ValueType *__restrict__ B0 = B; - for (int p=(m-1);p>=0;--p) { - const int iend = p, jend = n; + ValueType *__restrict__ B0 = B; + for (int p=(m-1);p>=0;--p) { + const int iend = p, jend = n; - const ValueType *__restrict__ a01 = A+p*as1; - ValueType *__restrict__ b1t = B+p*bs0; + const ValueType *__restrict__ a01 = A+p*as1; + ValueType *__restrict__ b1t = B+p*bs0; - if (!use_unit_diag) { - const ValueType alpha11 = A[p*as0+p*as1]; + if (!use_unit_diag) { + const ValueType alpha11 = A[p*as0+p*as1]; #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) #pragma unroll #endif - for (int j=0;j0){//Note: A workaround to produce correct results for complex with Intel-18.2.199 - for (int i=0;i0){//Note: A workaround to produce correct results for complex with Intel-18.2.199 + for (int i=0;i - template - KOKKOS_INLINE_FUNCTION - int - SerialTrsmInternalLeftUpper:: - invoke(const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsmInternalLeftUpper:: + invoke(const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; - if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); - else { - if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + if (alpha == zero) SerialSetInternal ::invoke(m, n, zero, B, bs0, bs1); + else { + if (alpha != one) SerialScaleInternal::invoke(m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, bs1); - InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, bs1); + InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, bs1); + InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, bs1); - InnerGemmFixA gemm(as0, as1, bs0, bs1, bs0, bs1); + InnerGemmFixA gemm(as0, as1, bs0, bs1, bs0, bs1); - auto trsm = [&](const int ib, - const int jb, - const ValueType *__restrict__ AA, - /**/ ValueType *__restrict__ BB) { - const int mb = mbAlgo; - for (int pp=0;pp p ? (p-i) : mb, jb, pb, BB+i*bs0); - } + // gemm update + for (int i=0;i p ? (p-i) : mb, jb, pb, BB+i*bs0); } - }; - - const bool is_small = (m*n <= 64*64); - if (is_small) { - trsm(m, n, A, B); - } else { - // // some cache blocking may need (not priority yet); - // trsm(m, n, A, B); } - } - return 0; - } - + }; + + const bool is_small = (m*n <= 64*64); + if (is_small) { + trsm(m, n, A, B); + } else { + // // some cache blocking may need (not priority yet); + // trsm(m, n, A, B); + } + } + return 0; } + } + #endif diff --git a/src/batched/KokkosBatched_Trsm_Team_Impl.hpp b/src/batched/KokkosBatched_Trsm_Team_Impl.hpp index a2f6e18c0b..0137e20eb1 100644 --- a/src/batched/KokkosBatched_Trsm_Team_Impl.hpp +++ b/src/batched/KokkosBatched_Trsm_Team_Impl.hpp @@ -7,244 +7,243 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Trsm_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Impl - /// ========= - - /// - /// L/L/NT - /// - /// B := inv(tril(A)) (alpha*B) - /// A(m x m), B(m x n) - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, - ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, + + /// + /// Team Impl + /// ========= + + /// + /// L/L/NT + /// + /// B := inv(tril(A)) (alpha*B) + /// A(m x m), B(m x n) + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, ArgDiag::use_unit_diag, B.extent(0), B.extent(1), alpha, A.data(), A.stride_0(), A.stride_1(), B.data(), B.stride_0(), B.stride_1()); - } - }; - - /// - /// R/U/NT - /// - /// B := (alpha*B) inv(triu(A)) - /// A(n x n), B(m x n) - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, - ArgDiag::use_unit_diag, - B.extent(1), B.extent(0), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_1(), B.stride_0()); - } - }; - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, + } + }; + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, + ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; + + /// + /// R/U/NT + /// + /// B := (alpha*B) inv(triu(A)) + /// A(n x n), B(m x n) + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, ArgDiag::use_unit_diag, B.extent(1), B.extent(0), alpha, A.data(), A.stride_1(), A.stride_0(), B.data(), B.stride_1(), B.stride_0()); - } - }; + } + }; + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, + ArgDiag::use_unit_diag, + B.extent(1), B.extent(0), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_1(), B.stride_0()); + } + }; - /// - /// L/U/NT - /// - /// B := inv(triu(A)) (alpha*B) - /// A(m x m), B(m x n) - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftUpper::invoke(member, - ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_0(), A.stride_1(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftUpper::invoke(member, + /// + /// L/U/NT + /// + /// B := inv(triu(A)) (alpha*B) + /// A(m x m), B(m x n) + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftUpper::invoke(member, ArgDiag::use_unit_diag, B.extent(0), B.extent(1), alpha, A.data(), A.stride_0(), A.stride_1(), B.data(), B.stride_0(), B.stride_1()); - } - }; - - /// - /// L/L/T - /// - /// B := inv(tril(AT)) (alpha*B) - /// A(m x m), B(m x n) - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, - ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftLower::invoke(member, + } + }; + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftUpper::invoke(member, + ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_0(), A.stride_1(), + B.data(), B.stride_0(), B.stride_1()); + } + }; + + /// + /// L/L/T + /// + /// B := inv(tril(AT)) (alpha*B) + /// A(m x m), B(m x n) + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, ArgDiag::use_unit_diag, B.extent(0), B.extent(1), alpha, A.data(), A.stride_1(), A.stride_0(), B.data(), B.stride_0(), B.stride_1()); - } - }; - - /// - /// L/U/T - /// - /// B := inv(triu(AT)) (alpha*B) - /// A(m x m), B(m x n) - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftUpper::invoke(member, - ArgDiag::use_unit_diag, - B.extent(0), B.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - B.data(), B.stride_0(), B.stride_1()); - } - }; - - template - struct TeamTrsm { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const BViewType &B) { - return TeamTrsmInternalLeftUpper::invoke(member, + } + }; + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftLower::invoke(member, + ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; + + /// + /// L/U/T + /// + /// B := inv(triu(AT)) (alpha*B) + /// A(m x m), B(m x n) + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftUpper::invoke(member, ArgDiag::use_unit_diag, B.extent(0), B.extent(1), alpha, A.data(), A.stride_1(), A.stride_0(), B.data(), B.stride_0(), B.stride_1()); - } - }; + } + }; + + template + struct TeamTrsm { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const BViewType &B) { + return TeamTrsmInternalLeftUpper::invoke(member, + ArgDiag::use_unit_diag, + B.extent(0), B.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + B.data(), B.stride_0(), B.stride_1()); + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Trsm_Team_Internal.hpp b/src/batched/KokkosBatched_Trsm_Team_Internal.hpp index 1bac956e0a..085bd9e293 100644 --- a/src/batched/KokkosBatched_Trsm_Team_Internal.hpp +++ b/src/batched/KokkosBatched_Trsm_Team_Internal.hpp @@ -12,312 +12,311 @@ #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" #include "KokkosBatched_Gemm_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Internal Impl - /// ==================== - - template - struct TeamTrsmInternalLeftLower { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1); - }; - template<> + /// + /// Team Internal Impl + /// ==================== + + template + struct TeamTrsmInternalLeftLower { template KOKKOS_INLINE_FUNCTION - int - TeamTrsmInternalLeftLower:: + static int invoke(const MemberType &member, const bool use_unit_diag, - const int m, const int n, + const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - - const ScalarType one(1.0), zero(0.0); - - if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; - - for (int p=0;p + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsmInternalLeftLower:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + + const ScalarType one(1.0), zero(0.0); + + if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; + + for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - TeamTrsmInternalLeftLower:: - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend*jend),[&](const int &ij) { + // assume layout right for batched computation + const int i = ij/jend, j = ij%jend; + B2[i*bs0+j*bs1] -= a21[i*as0] * b1t[j*bs1]; + }); + } + } + return 0; + } - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsmInternalLeftLower:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - // note that parallel range is different ( m*n vs m-1*n); - if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + // note that parallel range is different ( m*n vs m-1*n); + if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - /// - /// case host: team size is small and blocksize (mb,nb) is large + /// + /// case host: team size is small and blocksize (mb,nb) is large - /// - /// case cuda: team size is large and blocksize (mb,nb) is small - InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, bs1); - InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, bs1); + /// + /// case cuda: team size is large and blocksize (mb,nb) is small + InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, bs1); + InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, bs1); - auto trsm = [&](const int ib, - const int jb, - const ValueType *__restrict__ AA, - /**/ ValueType *__restrict__ BB) { - const int mb = mbAlgo; - const int tsize = member.team_size(); + auto trsm = [&](const int ib, + const int jb, + const ValueType *__restrict__ AA, + /**/ ValueType *__restrict__ BB) { + const int mb = mbAlgo; + const int tsize = member.team_size(); + // Made this non-const in order to WORKAROUND issue #349 + int nb = (jb/tsize + jb%tsize > 0); + int np = jb%nb; + for (int p=0;p 0); - int np = jb%nb; - for (int p=0;p ib ? (ib-p) : mb); + int pb = ((p+mb) > ib ? (ib-p) : mb); - // trsm update - const ValueType *__restrict__ Ap = AA+p*as0+p*as1; - /**/ ValueType *__restrict__ Bp = BB+p*bs0; + // trsm update + const ValueType *__restrict__ Ap = AA+p*as0+p*as1; + /**/ ValueType *__restrict__ Bp = BB+p*bs0; - member.team_barrier(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,(jb/nb)+(np>0)),[&](const int jj) { - // Made this non-const in order to WORKAROUND issue #349 - int j = jj*nb, qb = (j+nb) > jb ? np : nb; - if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, qb, Bp+j*bs1); - else trsm_n.serial_invoke(Ap, pb, qb, Bp+j*bs1); - }); - member.team_barrier(); + member.team_barrier(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,(jb/nb)+(np>0)),[&](const int jj) { + // Made this non-const in order to WORKAROUND issue #349 + int j = jj*nb, qb = (j+nb) > jb ? np : nb; + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, qb, Bp+j*bs1); + else trsm_n.serial_invoke(Ap, pb, qb, Bp+j*bs1); + }); + member.team_barrier(); - // gemm update - TeamGemmInternal - ::invoke(member, - ib-p-pb, jb, pb, - minus_one, - Ap+pb*as0, as0, as1, - Bp, bs0, bs1, - one, - Bp+pb*bs0, bs0, bs1); - } - }; - - const bool is_small = true; //(m*n <= 64*64); - if (is_small) { - trsm(m, n, A, B); - } else { - // // some cache blocking may need (not priority yet); - // trsm(m, n, A, B); + // gemm update + TeamGemmInternal + ::invoke(member, + ib-p-pb, jb, pb, + minus_one, + Ap+pb*as0, as0, as1, + Bp, bs0, bs1, + one, + Bp+pb*bs0, bs0, bs1); } + }; + + const bool is_small = true; //(m*n <= 64*64); + if (is_small) { + trsm(m, n, A, B); + } else { + // // some cache blocking may need (not priority yet); + // trsm(m, n, A, B); } - return 0; } + return 0; + } - template - struct TeamTrsmInternalLeftUpper { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1); - }; - - template<> + template + struct TeamTrsmInternalLeftUpper { template KOKKOS_INLINE_FUNCTION - int - TeamTrsmInternalLeftUpper:: + static int invoke(const MemberType &member, const bool use_unit_diag, - const int m, const int n, + const int m, const int n, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - - const ScalarType one(1.0), zero(0.0); - - // note that parallel range is different ( m*n vs m-1*n); - if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + /**/ ValueType *__restrict__ B, const int bs0, const int bs1); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsmInternalLeftUpper:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + + const ScalarType one(1.0), zero(0.0); + + // note that parallel range is different ( m*n vs m-1*n); + if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - ValueType *__restrict__ B0 = B; - for (int p=(m-1);p>=0;--p) { - // Made this non-const in order to WORKAROUND issue #349 - int iend = p; - int jend = n; - - const ValueType *__restrict__ a01 = A+p*as1; - /**/ ValueType *__restrict__ b1t = B+p*bs0; + ValueType *__restrict__ B0 = B; + for (int p=(m-1);p>=0;--p) { + // Made this non-const in order to WORKAROUND issue #349 + int iend = p; + int jend = n; + + const ValueType *__restrict__ a01 = A+p*as1; + /**/ ValueType *__restrict__ b1t = B+p*bs0; + member.team_barrier(); + if (!use_unit_diag) { + const ValueType alpha11 = A[p*as0+p*as1]; + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,jend),[&](const int &j) { + b1t[j*bs1] = b1t[j*bs1] / alpha11; + }); member.team_barrier(); - if (!use_unit_diag) { - const ValueType alpha11 = A[p*as0+p*as1]; - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,jend),[&](const int &j) { - b1t[j*bs1] = b1t[j*bs1] / alpha11; - }); - member.team_barrier(); - } - - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend*jend),[&](const int &ij) { + } + + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend*jend),[&](const int &ij) { #if \ - defined (KOKKOS_ENABLE_CUDA) && \ + defined (KOKKOS_ENABLE_CUDA) && \ defined (KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA) - const int i = ij%iend, j = ij/iend; + const int i = ij%iend, j = ij/iend; #else - const int i = ij/jend, j = ij%jend; + const int i = ij/jend, j = ij%jend; #endif - B0[i*bs0+j*bs1] -= a01[i*as0] * b1t[j*bs1]; - }); - } + B0[i*bs0+j*bs1] -= a01[i*as0] * b1t[j*bs1]; + }); } - return 0; } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - TeamTrsmInternalLeftUpper:: - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, const int n, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { - - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsmInternalLeftUpper:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, const int n, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ B, const int bs0, const int bs1) { + + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - // note that parallel range is different ( m*n vs m-1*n); - if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); - if (m <= 0 || n <= 0) return 0; + // note that parallel range is different ( m*n vs m-1*n); + if (alpha == zero) TeamSetInternal ::invoke(member, m, n, zero, B, bs0, bs1); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, n, alpha, B, bs0, bs1); + if (m <= 0 || n <= 0) return 0; - InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, bs1); - InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, bs1); + InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, bs1); + InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, bs1); - auto trsm = [&](const int ib, - const int jb, - const ValueType *__restrict__ AA, - /**/ ValueType *__restrict__ BB) { - const int mb = mbAlgo; //(ib <=5 ? ib : mbAlgo); - const int tsize = member.team_size(); - // Made this non-const in order to WORKAROUND issue #349 - int nb = (jb/tsize + jb%tsize > 0); - int np = jb%nb; - for (int pp=0;pp 0); + int np = jb%nb; + for (int pp=0;pp0)),[&](const int &jj) { - const int j = jj*nb, qb = (j+nb) > jb ? np : nb; - if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, qb, Bp+j*bs1); - else trsm_n.serial_invoke(Ap, pb, qb, Bp+j*bs1); - }); - member.team_barrier(); + // trsm update + const ValueType *__restrict__ Ap = AA+p*as0+p*as1; + /**/ ValueType *__restrict__ Bp = BB+p*bs0; + + member.team_barrier(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,(jb/nb)+(np>0)),[&](const int &jj) { + const int j = jj*nb, qb = (j+nb) > jb ? np : nb; + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, qb, Bp+j*bs1); + else trsm_n.serial_invoke(Ap, pb, qb, Bp+j*bs1); + }); + member.team_barrier(); - // gemm update - TeamGemmInternal - ::invoke(member, - p, jb, pb, - minus_one, - Ap-p*as0, as0, as1, - Bp, bs0, bs1, - one, - BB, bs0, bs1); - } - }; - - const bool is_small = true; //(m*n <= 64*64); - if (is_small) { - trsm(m, n, A, B); - } else { - // // some cache blocking may need (not priority yet); - // trsm(m, n, A, B); + // gemm update + TeamGemmInternal + ::invoke(member, + p, jb, pb, + minus_one, + Ap-p*as0, as0, as1, + Bp, bs0, bs1, + one, + BB, bs0, bs1); } - } - return 0; - } - + }; + + const bool is_small = true; //(m*n <= 64*64); + if (is_small) { + trsm(m, n, A, B); + } else { + // // some cache blocking may need (not priority yet); + // trsm(m, n, A, B); + } + } + return 0; } + } + #endif diff --git a/src/batched/KokkosBatched_Trsv_Decl.hpp b/src/batched/KokkosBatched_Trsv_Decl.hpp index b31cddeaf2..cd1e5000ae 100644 --- a/src/batched/KokkosBatched_Trsv_Decl.hpp +++ b/src/batched/KokkosBatched_Trsv_Decl.hpp @@ -7,133 +7,131 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Vector.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Trsv - /// - - template - struct SerialTrsv { - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b); - }; + + /// + /// Serial Trsv + /// + + template + struct SerialTrsv { + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b); + }; - /// - /// Team Trsv - /// - - template - struct TeamTrsv { - - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b); - }; - - - /// - /// Selective Interface - /// - template - struct Trsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - int r_val = 0; - if (std::is_same::value) { - r_val = SerialTrsv::invoke(alpha, A, b); - } else if (std::is_same::value) { - r_val = TeamTrsv::invoke(member, alpha, A, b); - } - return r_val; - } - }; + /// + /// Team Trsv + /// + + template + struct TeamTrsv { + + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b); + }; + + + /// + /// Selective Interface + /// + template + struct Trsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + int r_val = 0; + if (std::is_same::value) { + r_val = SerialTrsv::invoke(alpha, A, b); + } else if (std::is_same::value) { + r_val = TeamTrsv::invoke(member, alpha, A, b); + } + return r_val; + } + }; - } } #define KOKKOSBATCHED_SERIAL_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + KokkosBatched::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) #define KOKKOSBATCHED_SERIAL_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + KokkosBatched::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) #define KOKKOSBATCHED_SERIAL_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + KokkosBatched::SerialTrsvInternalUpper::invoke(DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) #define KOKKOSBATCHED_SERIAL_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + KokkosBatched::SerialTrsvInternalLower::invoke(DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) #define KOKKOSBATCHED_TEAM_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + KokkosBatched::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) #define KOKKOSBATCHED_TEAM_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + KokkosBatched::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) #define KOKKOSBATCHED_TEAM_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) + KokkosBatched::TeamTrsvInternalUpper::invoke(MEMBER,DIAG::use_unit_diag, M, ALPHA, A, AS0, AS1, B, BS) #define KOKKOSBATCHED_TEAM_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - KokkosBatched::Experimental::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) + KokkosBatched::TeamTrsvInternalLower::invoke(MEMBER,DIAG::use_unit_diag, N, ALPHA, A, AS1, AS0, B, BS) #define KOKKOSBATCHED_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_TRSV_LOWER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ } #define KOKKOSBATCHED_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_TRSV_LOWER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ } #define KOKKOSBATCHED_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_TRSV_UPPER_NO_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ } #define KOKKOSBATCHED_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(MODETYPE,ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS) \ - if (std::is_same::value) { \ + if (std::is_same::value) { \ KOKKOSBATCHED_SERIAL_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ - } else if (std::is_same::value) { \ + } else if (std::is_same::value) { \ KOKKOSBATCHED_TEAM_TRSV_UPPER_TRANSPOSE_INTERNAL_INVOKE(ALGOTYPE,MEMBER,DIAG,M,N,ALPHA,A,AS0,AS1,B,BS); \ } diff --git a/src/batched/KokkosBatched_Trsv_Serial_Impl.hpp b/src/batched/KokkosBatched_Trsv_Serial_Impl.hpp index 689052cca0..bca3254c27 100644 --- a/src/batched/KokkosBatched_Trsv_Serial_Impl.hpp +++ b/src/batched/KokkosBatched_Trsv_Serial_Impl.hpp @@ -7,406 +7,404 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Trsv_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Impl - /// =========== + /// + /// Serial Impl + /// =========== - /// - /// Implemented: - /// L/NT, U/NT, L/T, U/T - /// - /// Not yet implemented - /// L/CT, U/CT + /// + /// Implemented: + /// L/NT, U/NT, L/T, U/T + /// + /// Not yet implemented + /// L/CT, U/CT - /// - /// L/NT - /// + /// + /// L/NT + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - typedef typename bViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + typedef typename bViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = b.extent(0), - n = 1; + const int + m = b.extent(0), + n = 1; - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalLower:: - invoke(ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalLower:: + invoke(ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalLower:: - invoke(ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalLower:: + invoke(ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; - /// - /// L/T - /// + /// + /// L/T + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - typedef typename bViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + typedef typename bViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = b.extent(0), - n = 1; + const int + m = b.extent(0), + n = 1; - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_LOWER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_LOWER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalUpper:: - invoke(ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalUpper:: + invoke(ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalUpper:: - invoke(ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalUpper:: + invoke(ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; - /// - /// U/NT - /// + /// + /// U/NT + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - typedef typename bViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + typedef typename bViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = b.extent(0), - n = 1; + const int + m = b.extent(0), + n = 1; - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_NOTRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_NOTRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalUpper:: - invoke(ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalUpper:: + invoke(ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalUpper:: - invoke(ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalUpper:: + invoke(ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; - /// - /// U/T - /// + /// + /// U/T + /// #if \ defined(__KOKKOSBATCHED_INTEL_MKL__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) && \ defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - typedef typename bViewType::value_type vector_type; - //typedef typename vector_type::value_type value_type; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + typedef typename bViewType::value_type vector_type; + //typedef typename vector_type::value_type value_type; - const int - m = b.extent(0), - n = 1; + const int + m = b.extent(0), + n = 1; - static_assert(is_vector::value, "value type is not vector type"); - static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, - "AVX, AVX2 and AVX512 is supported"); - const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; + static_assert(is_vector::value, "value type is not vector type"); + static_assert(vector_type::vector_length == 4 || vector_type::vector_length == 8, + "AVX, AVX2 and AVX512 is supported"); + const MKL_COMPACT_PACK format = vector_type::vector_length == 8 ? MKL_COMPACT_AVX512 : MKL_COMPACT_AVX; - // no error check - int r_val = 0; - if (A.stride_0() == 1) { - mkl_dtrsm_compact(MKL_COL_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else if (A.stride_1() == 1) { - mkl_dtrsm_compact(MKL_ROW_MAJOR, - MKL_LEFT, MKL_UPPER, MKL_TRANS, - ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, - m, n, - alpha, - (const double*)A.data(), A.stride_0(), - (double*)b.data(), b.stride_0(), - format, (MKL_INT)vector_type::vector_length); - } else { - r_val = -1; - } - return r_val; + // no error check + int r_val = 0; + if (A.stride_0() == 1) { + mkl_dtrsm_compact(MKL_COL_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else if (A.stride_1() == 1) { + mkl_dtrsm_compact(MKL_ROW_MAJOR, + MKL_LEFT, MKL_UPPER, MKL_TRANS, + ArgDiag::use_unit_diag ? MKL_UNIT : MKL_NONUNIT, + m, n, + alpha, + (const double*)A.data(), A.stride_0(), + (double*)b.data(), b.stride_0(), + format, (MKL_INT)vector_type::vector_length); + } else { + r_val = -1; } - }; + return r_val; + } + }; #endif - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalLower:: - invoke(ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalLower:: + invoke(ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; - template - struct SerialTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return SerialTrsvInternalLower:: - invoke(ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; + template + struct SerialTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return SerialTrsvInternalLower:: + invoke(ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Trsv_Serial_Internal.hpp b/src/batched/KokkosBatched_Trsv_Serial_Internal.hpp index 97d0d68851..618f8dc614 100644 --- a/src/batched/KokkosBatched_Trsv_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_Trsv_Serial_Internal.hpp @@ -12,234 +12,232 @@ #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" #include "KokkosBatched_Gemv_Serial_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Serial Internal Impl - /// ==================== - - /// - /// Lower - /// - - template - struct SerialTrsvInternalLower { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0); - }; - - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialTrsvInternalLower:: - invoke(const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0); - if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); - else { - if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); - if (m <= 0) return 0; + /// + /// Serial Internal Impl + /// ==================== - for (int p=0;p + template + struct SerialTrsvInternalLower { template KOKKOS_INLINE_FUNCTION - int - SerialTrsvInternalLower:: + static int invoke(const bool use_unit_diag, const int m, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - - enum : int { - mbAlgo = Algo::Trsv::Blocked::mb() - }; - - if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); - else { - if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); - if (m <= 0) return 0; - - /// case cuda: team size is large and blocksize (mb,nb) is small - InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, 0); - InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, 0); - - const int mb = mbAlgo; - for (int p=0;p m ? (m-p) : mb); - - // trsm update - const ValueType *__restrict__ Ap = A+p*as0+p*as1; - /**/ ValueType *__restrict__ bp = b+p*bs0; - - if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, 1, bp); - else trsm_n.serial_invoke(Ap, pb, 1, bp); - - // gemv update - SerialGemvInternal - ::invoke(m-p-pb, pb, - minus_one, - Ap+pb*as0, as0, as1, - bp, bs0, - one, - bp+pb*bs0, bs0); - } + /**/ ValueType *__restrict__ b, const int bs0); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsvInternalLower:: + invoke(const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0); + + if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); + else { + if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); + if (m <= 0) return 0; + + for (int p=0;p - struct SerialTrsvInternalUpper { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0); - + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsvInternalLower:: + invoke(const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + + enum : int { + mbAlgo = Algo::Trsv::Blocked::mb() }; - template<> - template - KOKKOS_INLINE_FUNCTION - int - SerialTrsvInternalUpper:: - invoke(const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0); - - if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); - else { - if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); - if (m <= 0) return 0; - - ValueType *__restrict__ b0 = b; - for (int p=(m-1);p>=0;--p) { - const int iend = p; - - const ValueType *__restrict__ a01 = A+p*as1; - /**/ ValueType *__restrict__ beta1 = b+p*bs0; - - // with __restrict__ a compiler assumes that the pointer is not accessed by others - // op(/=) uses this pointer and changes the associated values, which brings a compiler problem - if (!use_unit_diag) - *beta1 = *beta1 / A[p*as0+p*as1]; - - for (int i=0;i trsm_u(as0, as1, bs0, 0); + InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, 0); + + const int mb = mbAlgo; + for (int p=0;p m ? (m-p) : mb); + + // trsm update + const ValueType *__restrict__ Ap = A+p*as0+p*as1; + /**/ ValueType *__restrict__ bp = b+p*bs0; + + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, 1, bp); + else trsm_n.serial_invoke(Ap, pb, 1, bp); + + // gemv update + SerialGemvInternal + ::invoke(m-p-pb, pb, + minus_one, + Ap+pb*as0, as0, as1, + bp, bs0, + one, + bp+pb*bs0, bs0); } - return 0; } + return 0; + } + + /// + /// Upper + /// - template<> + template + struct SerialTrsvInternalUpper { template KOKKOS_INLINE_FUNCTION - int - SerialTrsvInternalUpper:: + static int invoke(const bool use_unit_diag, const int m, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; - - // note that parallel range is different ( m*n vs m-1*n); - if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); - else { - if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); - if (m <= 0) return 0; - - InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, 0); - InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, 0); - - const int mb = mbAlgo; - for (int pp=0;pp - ::invoke(p, pb, - minus_one, - Ap-p*as0, as0, as1, - bp, bs0, - one, - b, bs0); - } + /**/ ValueType *__restrict__ b, const int bs0); + + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsvInternalUpper:: + invoke(const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0); + + if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); + else { + if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); + if (m <= 0) return 0; + + ValueType *__restrict__ b0 = b; + for (int p=(m-1);p>=0;--p) { + const int iend = p; + + const ValueType *__restrict__ a01 = A+p*as1; + /**/ ValueType *__restrict__ beta1 = b+p*bs0; + + // with __restrict__ a compiler assumes that the pointer is not accessed by others + // op(/=) uses this pointer and changes the associated values, which brings a compiler problem + if (!use_unit_diag) + *beta1 = *beta1 / A[p*as0+p*as1]; + + for (int i=0;i + template + KOKKOS_INLINE_FUNCTION + int + SerialTrsvInternalUpper:: + invoke(const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; + // note that parallel range is different ( m*n vs m-1*n); + if (alpha == zero) SerialSetInternal::invoke(m, zero, b, bs0); + else { + if (alpha != one) SerialScaleInternal::invoke(m, alpha, b, bs0); + if (m <= 0) return 0; + + InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, 0); + InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, 0); + + const int mb = mbAlgo; + for (int pp=0;pp + ::invoke(p, pb, + minus_one, + Ap-p*as0, as0, as1, + bp, bs0, + one, + b, bs0); + } + } + return 0; } + } + #endif diff --git a/src/batched/KokkosBatched_Trsv_Team_Impl.hpp b/src/batched/KokkosBatched_Trsv_Team_Impl.hpp index 7a5e7aba7b..d19cc17853 100644 --- a/src/batched/KokkosBatched_Trsv_Team_Impl.hpp +++ b/src/batched/KokkosBatched_Trsv_Team_Impl.hpp @@ -7,205 +7,202 @@ #include "KokkosBatched_Util.hpp" #include "KokkosBatched_Trsv_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - - /// - /// Team Impl - /// =========== - - /// - /// Implemented: - /// L/NT, U/NT, L/T, U/T - /// - /// Not yet implemented - /// L/CT, U/CT - - /// - /// L/NT - /// + /// + /// Team Impl + /// =========== + + /// + /// Implemented: + /// L/NT, U/NT, L/T, U/T + /// + /// Not yet implemented + /// L/CT, U/CT + + /// + /// L/NT + /// - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalLower:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalLower:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; - - /// - /// L/T - /// - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalUpper:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalUpper:: - invoke(ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; - - /// - /// U/NT - /// - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalUpper:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalUpper:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(0), - alpha, - A.data(), A.stride_0(), A.stride_1(), - b.data(), b.stride_0()); - } - }; - - /// - /// U/T - /// - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalLower:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; - - template - struct TeamTrsv { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const ScalarType alpha, - const AViewType &A, - const bViewType &b) { - return TeamTrsvInternalLower:: - invoke(member, - ArgDiag::use_unit_diag, - A.extent(1), - alpha, - A.data(), A.stride_1(), A.stride_0(), - b.data(), b.stride_0()); - } - }; - } + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalLower:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalLower:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; + + /// + /// L/T + /// + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalUpper:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalUpper:: + invoke(ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; + + /// + /// U/NT + /// + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalUpper:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalUpper:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(0), + alpha, + A.data(), A.stride_0(), A.stride_1(), + b.data(), b.stride_0()); + } + }; + + /// + /// U/T + /// + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalLower:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; + + template + struct TeamTrsv { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const MemberType &member, + const ScalarType alpha, + const AViewType &A, + const bViewType &b) { + return TeamTrsvInternalLower:: + invoke(member, + ArgDiag::use_unit_diag, + A.extent(1), + alpha, + A.data(), A.stride_1(), A.stride_0(), + b.data(), b.stride_0()); + } + }; } + #endif diff --git a/src/batched/KokkosBatched_Trsv_Team_Internal.hpp b/src/batched/KokkosBatched_Trsv_Team_Internal.hpp index a35fb7c5cc..1c9af46812 100644 --- a/src/batched/KokkosBatched_Trsv_Team_Internal.hpp +++ b/src/batched/KokkosBatched_Trsv_Team_Internal.hpp @@ -12,267 +12,266 @@ #include "KokkosBatched_InnerTrsm_Serial_Impl.hpp" #include "KokkosBatched_Gemv_Team_Internal.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Team Internal Impl - /// ==================== - - /// - /// Lower - /// - - template - struct TeamTrsvInternalLower { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0); - }; - template<> + /// + /// Team Internal Impl + /// ==================== + + /// + /// Lower + /// + + template + struct TeamTrsvInternalLower { template KOKKOS_INLINE_FUNCTION - int - TeamTrsvInternalLower:: + static int invoke(const MemberType &member, const bool use_unit_diag, const int m, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0); - - if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); - if (m <= 0) return 0; - - for (int p=0;p + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsvInternalLower:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0); + + if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); + if (m <= 0) return 0; + + for (int p=0;p - template - KOKKOS_INLINE_FUNCTION - int - TeamTrsvInternalLower:: - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - - enum : int { - mbAlgo = Algo::Trsv::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsvInternalLower:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + + enum : int { + mbAlgo = Algo::Trsv::Blocked::mb() + }; - if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); - if (m <= 0) return 0; + if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); + if (m <= 0) return 0; - /// case cuda: team size is large and blocksize (mb,nb) is small - InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, 0); - InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, 0); + /// case cuda: team size is large and blocksize (mb,nb) is small + InnerTrsmLeftLowerUnitDiag trsm_u(as0, as1, bs0, 0); + InnerTrsmLeftLowerNonUnitDiag trsm_n(as0, as1, bs0, 0); - const int mb = mbAlgo; - //const int tsize = member.team_size(); - for (int p=0;p m ? (m-p) : mb); + const int mb = mbAlgo; + //const int tsize = member.team_size(); + for (int p=0;p m ? (m-p) : mb); - // trsm update - const ValueType *__restrict__ Ap = A+p*as0+p*as1; - /**/ ValueType *__restrict__ bp = b+p*bs0; + // trsm update + const ValueType *__restrict__ Ap = A+p*as0+p*as1; + /**/ ValueType *__restrict__ bp = b+p*bs0; - member.team_barrier(); - if (member.team_rank() == 0) { - if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, 1, bp); - else trsm_n.serial_invoke(Ap, pb, 1, bp); - } - - // gemv update - member.team_barrier(); - TeamGemvInternal - ::invoke(member, - m-p-pb, pb, - minus_one, - Ap+pb*as0, as0, as1, - bp, 1, - one, - bp+pb*bs0, bs0); + member.team_barrier(); + if (member.team_rank() == 0) { + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, 1, bp); + else trsm_n.serial_invoke(Ap, pb, 1, bp); } + + // gemv update + member.team_barrier(); + TeamGemvInternal + ::invoke(member, + m-p-pb, pb, + minus_one, + Ap+pb*as0, as0, as1, + bp, 1, + one, + bp+pb*bs0, bs0); } - return 0; } + return 0; + } - /// - /// Upper - /// - - template - struct TeamTrsvInternalUpper { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0); - }; + /// + /// Upper + /// - template<> + template + struct TeamTrsvInternalUpper { template KOKKOS_INLINE_FUNCTION - int - TeamTrsvInternalUpper:: + static int invoke(const MemberType &member, const bool use_unit_diag, const int m, const ScalarType alpha, const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0); - - if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); - if (m <= 0) return 0; - - ValueType *__restrict__ b0 = b; - for (int p=(m-1);p>=0;--p) { - const int iend = p; - - const ValueType *__restrict__ a01 = A+p*as1; - /**/ ValueType *__restrict__ beta1 = b+p*bs0; - - member.team_barrier(); - ValueType local_beta1 = *beta1; - if (!use_unit_diag) { - const ValueType alpha11 = A[p*as0+p*as1]; - local_beta1 = local_beta1 / alpha11; - - if (member.team_rank() == 0) - *beta1 = local_beta1; - } - - member.team_barrier(); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend),[&](const int &i) { - b0[i*bs0] -= a01[i*as0] * local_beta1; - }); + /**/ ValueType *__restrict__ b, const int bs0); + }; + + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsvInternalUpper:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0); + + if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); + if (m <= 0) return 0; + + ValueType *__restrict__ b0 = b; + for (int p=(m-1);p>=0;--p) { + const int iend = p; + + const ValueType *__restrict__ a01 = A+p*as1; + /**/ ValueType *__restrict__ beta1 = b+p*bs0; + + member.team_barrier(); + ValueType local_beta1 = *beta1; + if (!use_unit_diag) { + const ValueType alpha11 = A[p*as0+p*as1]; + local_beta1 = local_beta1 / alpha11; + + if (member.team_rank() == 0) + *beta1 = local_beta1; } + + member.team_barrier(); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,iend),[&](const int &i) { + b0[i*bs0] -= a01[i*as0] * local_beta1; + }); } - return 0; } + return 0; + } - template<> - template - KOKKOS_INLINE_FUNCTION - int - TeamTrsvInternalUpper:: - invoke(const MemberType &member, - const bool use_unit_diag, - const int m, - const ScalarType alpha, - const ValueType *__restrict__ A, const int as0, const int as1, - /**/ ValueType *__restrict__ b, const int bs0) { - - const ScalarType one(1.0), zero(0.0), minus_one(-1.0); - - enum : int { - mbAlgo = Algo::Trsm::Blocked::mb() - }; + template<> + template + KOKKOS_INLINE_FUNCTION + int + TeamTrsvInternalUpper:: + invoke(const MemberType &member, + const bool use_unit_diag, + const int m, + const ScalarType alpha, + const ValueType *__restrict__ A, const int as0, const int as1, + /**/ ValueType *__restrict__ b, const int bs0) { + + const ScalarType one(1.0), zero(0.0), minus_one(-1.0); + + enum : int { + mbAlgo = Algo::Trsm::Blocked::mb() + }; - // note that parallel range is different ( m*n vs m-1*n); - if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); - else { - if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); - if (m <= 0) return 0; + // note that parallel range is different ( m*n vs m-1*n); + if (alpha == zero) TeamSetInternal::invoke(member, m, zero, b, bs0); + else { + if (alpha != one) TeamScaleInternal::invoke(member, m, alpha, b, bs0); + if (m <= 0) return 0; - InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, 0); - InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, 0); + InnerTrsmLeftUpperUnitDiag trsm_u(as0, as1, bs0, 0); + InnerTrsmLeftUpperNonUnitDiag trsm_n(as0, as1, bs0, 0); - const int mb = mbAlgo; - for (int pp=0;pp - ::invoke(member, - p, pb, - minus_one, - Ap-p*as0, as0, as1, - bp, 1, - one, - b, bs0); + member.team_barrier(); + if (member.team_rank() == 0) { + if (use_unit_diag) trsm_u.serial_invoke(Ap, pb, 1, bp); + else trsm_n.serial_invoke(Ap, pb, 1, bp); } + + // gemv update + member.team_barrier(); + TeamGemvInternal + ::invoke(member, + p, pb, + minus_one, + Ap-p*as0, as0, as1, + bp, 1, + one, + b, bs0); } - return 0; } + return 0; } } + #endif diff --git a/src/batched/KokkosBatched_UpdateGivens_Internal.hpp b/src/batched/KokkosBatched_UpdateGivens_Internal.hpp index 5c7967bf31..4a2ac41b12 100644 --- a/src/batched/KokkosBatched_UpdateGivens_Internal.hpp +++ b/src/batched/KokkosBatched_UpdateGivens_Internal.hpp @@ -6,31 +6,29 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialUpdateGivensInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const Kokkos::pair &S, - /* */ Kokkos::pair &G) { - const ValueType - tmp = S.first*G.first -S.second*G.second; - G.second = S.first*G.second+S.second*G.first; - G.first = tmp; - - return 0; - } - }; - - }// end namespace Experimental + + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialUpdateGivensInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const Kokkos::pair &S, + /* */ Kokkos::pair &G) { + const ValueType + tmp = S.first*G.first -S.second*G.second; + G.second = S.first*G.second+S.second*G.first; + G.first = tmp; + + return 0; + } + }; + } // end namespace KokkosBatched diff --git a/src/batched/KokkosBatched_Util.cpp b/src/batched/KokkosBatched_Util.cpp index 0572c1eb24..21eb9db9a3 100644 --- a/src/batched/KokkosBatched_Util.cpp +++ b/src/batched/KokkosBatched_Util.cpp @@ -3,45 +3,43 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) namespace KokkosBatched { - namespace Experimental { - void print_compiler_info() { - printf(" supported pragmas:\n"); + void print_compiler_info() { + printf(" supported pragmas:\n"); #if defined(KOKKOS_ENABLE_PRAGMA_UNROLL) - printf(" #pragma unroll\n"); + printf(" #pragma unroll\n"); #endif #if defined(KOKKOS_ENABLE_PRAGMA_IVDEP) - printf(" #pragma ivdep\n"); + printf(" #pragma ivdep\n"); #endif #if defined KOKKOS_ENABLE_PRAGMA_VECTOR - printf(" #pragma vector always\n"); + printf(" #pragma vector always\n"); #endif #if !defined(KOKKOS_DEBUG) #if defined(KOKKOS_ENABLE_PRAGMA_SIMD) - printf(" #pragma simd\n"); + printf(" #pragma simd\n"); #endif #endif - printf("\n"); + printf("\n"); - printf(" supported avx intrinsics:\n"); + printf(" supported avx intrinsics:\n"); #if defined(__AVX__) || defined(__AVX2__) - printf(" __m256d : "); + printf(" __m256d : "); #if defined(__AVX__) - printf("AVX "); + printf("AVX "); #endif #if defined(__AVX2__) - printf("AVX2 "); + printf("AVX2 "); #endif - printf("\n"); + printf("\n"); #endif #if defined(__AVX512F__) - printf(" __m512d : AVX512F"); + printf(" __m512d : AVX512F"); #endif #if defined(__FMA__) - printf(" FMA is supported\n"); + printf(" FMA is supported\n"); #else - printf(" FMA is not supported\n"); + printf(" FMA is not supported\n"); #endif - } } } diff --git a/src/batched/KokkosBatched_Util.hpp b/src/batched/KokkosBatched_Util.hpp index 95dcb3c912..361ccd7a7f 100644 --- a/src/batched/KokkosBatched_Util.hpp +++ b/src/batched/KokkosBatched_Util.hpp @@ -24,9 +24,8 @@ #include "KokkosKernels_config.h" namespace KokkosBatched { - namespace Experimental { - // TPL macros + // TPL macros #if defined (KOKKOSKERNELS_ENABLE_TPL_MKL) #define __KOKKOSBATCHED_INTEL_MKL__ 1 #include "mkl_version.h" @@ -34,7 +33,7 @@ namespace KokkosBatched { #define __KOKKOSBATCHED_INTEL_MKL_BATCHED__ 1 #define __KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__ 1 #include "mkl.h" -//#include "mkl_types.h" + //#include "mkl_types.h" #endif #endif @@ -46,523 +45,523 @@ namespace KokkosBatched { #define Int2String(A) Int2StringHelper(A) #define StringCat(A,B) A B - void print_compiler_info(); + void print_compiler_info(); - template struct is_vector : public std::false_type {}; + template struct is_vector : public std::false_type {}; - template - struct is_same_mag_type { - static const bool is_specialized = ( Kokkos::Details::ArithTraits::is_specialized && - Kokkos::Details::ArithTraits::is_specialized ); + template + struct is_same_mag_type { + static const bool is_specialized = ( Kokkos::Details::ArithTraits::is_specialized && + Kokkos::Details::ArithTraits::is_specialized ); - static const bool is_mag_type_same = std::is_same::mag_type, - typename Kokkos::Details::ArithTraits::mag_type>::value; + static const bool is_mag_type_same = std::is_same::mag_type, + typename Kokkos::Details::ArithTraits::mag_type>::value; - static const bool value = is_specialized && is_mag_type_same; - }; + static const bool value = is_specialized && is_mag_type_same; + }; - // to use double, std::complex, Kokkos::complex - using std::abs; - using std::min; - using std::max; - - // view manipulation - template - using MemoryTraits = Kokkos::MemoryTraits; - - template - using UnmanagedViewType - = Kokkos::View >; - - template - using ConstViewType = Kokkos::View; - template - using ConstUnmanagedViewType = ConstViewType >; - - template - using ScratchViewType - = Kokkos::View >; - - - // helper for vector type - template - KOKKOS_INLINE_FUNCTION - typename std::enable_if::value,size_t>::type - adjustDimension(const size_t &m) { - return m; - } - - template - KOKKOS_INLINE_FUNCTION - typename std::enable_if::value,size_t>::type - adjustDimension(const size_t &m) { - return (m/T::vector_length + (m%T::vector_length > 0)); - } + // to use double, std::complex, Kokkos::complex + using std::abs; + using std::min; + using std::max; + + // view manipulation + template + using MemoryTraits = Kokkos::MemoryTraits; + + template + using UnmanagedViewType + = Kokkos::View >; + + template + using ConstViewType = Kokkos::View; + template + using ConstUnmanagedViewType = ConstViewType >; + + template + using ScratchViewType + = Kokkos::View >; + + + // helper for vector type + template + KOKKOS_INLINE_FUNCTION + typename std::enable_if::value,size_t>::type + adjustDimension(const size_t &m) { + return m; + } - template - struct Flush { - typedef double value_type; - - // flush a large host buffer - Kokkos::View _buf; - Flush() : _buf("Flush::buf", BufSize/sizeof(double)) { - Kokkos::deep_copy(_buf, 1); - } - - KOKKOS_INLINE_FUNCTION - void init(value_type &update) { - update = 0; - } - - KOKKOS_INLINE_FUNCTION - void join(volatile value_type &update, - const volatile value_type &input) { - update += input; - } - - KOKKOS_INLINE_FUNCTION - void operator()(const int i, value_type &update) const { - update += _buf[i]; - } - - void run() { - double sum = 0; - Kokkos::parallel_reduce(Kokkos::RangePolicy(0,BufSize/sizeof(double)), *this, sum); - SpaceType::fence(); - FILE *fp = fopen("/dev/null", "w"); - fprintf(fp, "%f\n", sum); - fclose(fp); - } + template + KOKKOS_INLINE_FUNCTION + typename std::enable_if::value,size_t>::type + adjustDimension(const size_t &m) { + return (m/T::vector_length + (m%T::vector_length > 0)); + } - }; + template + struct Flush { + typedef double value_type; - template - struct Random; - - template - struct Random::value || - std::is_same::value, T>::type> { - Random(const unsigned int seed = 0) { srand(seed); } - T value() { - const auto val = (rand()/((T) RAND_MAX) - 0.5)*2.0; - return val > 0 ? val + 1.0e-3 : val - 1.0e-3; - } - }; + // flush a large host buffer + Kokkos::View _buf; + Flush() : _buf("Flush::buf", BufSize/sizeof(double)) { + Kokkos::deep_copy(_buf, 1); + } - template - struct Random >::value || - std::is_same >::value || - std::is_same >::value || - std::is_same >::value, T>::type> { - Random(const unsigned int seed = 0) { srand(seed); } - T value() { - const auto rval = (rand()/((double) RAND_MAX) - 0.5)*2.0; - const auto ival = (rand()/((double) RAND_MAX) - 0.5)*2.0; - return T(rval > 0 ? rval + 1.0e-3 : rval - 1.0e-3, - ival > 0 ? ival + 1.0e-3 : ival - 1.0e-3); - } - }; + KOKKOS_INLINE_FUNCTION + void init(value_type &update) { + update = 0; + } - struct Timer { - std::string _label; - Kokkos::Impl::Timer _clock; - Timer (const std::string label) - : _label(label), _clock() {}; - - void reset() { _clock.reset(); } - double seconds() { return _clock.seconds(); } - ~Timer() { - Kokkos::fence(); - const double t = _clock.seconds(); - std::string label = _label; label.resize(24); - std::cout << "KokkosKernels::Timer:: " << std::setw(26) << label - << std::setw(15) << std::scientific << t << " [sec] " << std::endl; - } - }; + KOKKOS_INLINE_FUNCTION + void join(volatile value_type &update, + const volatile value_type &input) { + update += input; + } - // Implicit vectorization - template - struct SIMD { - static_assert( std::is_same::value || - std::is_same::value || - std::is_same::value || - std::is_same::value || - std::is_same::value || - std::is_same >::value || - std::is_same >::value || - std::is_same >::value || - std::is_same >::value, - "KokkosKernels:: Invalid SIMD<> type." ); - using value_type = T; - }; + KOKKOS_INLINE_FUNCTION + void operator()(const int i, value_type &update) const { + update += _buf[i]; + } - // Intel AVX instruction device (explicit vectorization) - template - struct AVX { - static_assert( std::is_same::value || - std::is_same::value || - std::is_same >::value || - std::is_same >::value, - "KokkosKernels:: Invalid AVX<> type." ); - using value_type = T; - }; + void run() { + double sum = 0; + Kokkos::parallel_reduce(Kokkos::RangePolicy(0,BufSize/sizeof(double)), *this, sum); + SpaceType::fence(); + FILE *fp = fopen("/dev/null", "w"); + fprintf(fp, "%f\n", sum); + fclose(fp); + } - // Tags for BLAS - struct Trans { - struct Transpose {}; - struct NoTranspose {}; - struct ConjTranspose {}; - }; + }; - struct Side { - struct Left {}; - struct Right {}; - }; + template + struct Random; - struct Uplo { - struct Upper {}; - struct Lower {}; + template + struct Random::value || + std::is_same::value, T>::type> { + Random(const unsigned int seed = 0) { srand(seed); } + T value() { + const auto val = (rand()/((T) RAND_MAX) - 0.5)*2.0; + return val > 0 ? val + 1.0e-3 : val - 1.0e-3; + } + }; + + template + struct Random >::value || + std::is_same >::value || + std::is_same >::value || + std::is_same >::value, T>::type> { + Random(const unsigned int seed = 0) { srand(seed); } + T value() { + const auto rval = (rand()/((double) RAND_MAX) - 0.5)*2.0; + const auto ival = (rand()/((double) RAND_MAX) - 0.5)*2.0; + return T(rval > 0 ? rval + 1.0e-3 : rval - 1.0e-3, + ival > 0 ? ival + 1.0e-3 : ival - 1.0e-3); + } + }; + + struct Timer { + std::string _label; + Kokkos::Impl::Timer _clock; + Timer (const std::string label) + : _label(label), _clock() {}; + + void reset() { _clock.reset(); } + double seconds() { return _clock.seconds(); } + ~Timer() { + Kokkos::fence(); + const double t = _clock.seconds(); + std::string label = _label; label.resize(24); + std::cout << "KokkosKernels::Timer:: " << std::setw(26) << label + << std::setw(15) << std::scientific << t << " [sec] " << std::endl; + } + }; + + // Implicit vectorization + template + struct SIMD { + static_assert( std::is_same::value || + std::is_same::value || + std::is_same::value || + std::is_same::value || + std::is_same::value || + std::is_same >::value || + std::is_same >::value || + std::is_same >::value || + std::is_same >::value, + "KokkosKernels:: Invalid SIMD<> type." ); + using value_type = T; + }; + + // Intel AVX instruction device (explicit vectorization) + template + struct AVX { + static_assert( std::is_same::value || + std::is_same::value || + std::is_same >::value || + std::is_same >::value, + "KokkosKernels:: Invalid AVX<> type." ); + using value_type = T; + }; + + // Tags for BLAS + struct Trans { + struct Transpose {}; + struct NoTranspose {}; + struct ConjTranspose {}; + }; + + struct Side { + struct Left {}; + struct Right {}; + }; + + struct Uplo { + struct Upper {}; + struct Lower {}; + }; + + struct Diag { + struct Unit { static const bool use_unit_diag = true; }; + struct NonUnit { static const bool use_unit_diag = false; }; + }; + + struct Mode { + struct Serial { + static const char *name() { return "Serial"; } }; - - struct Diag { - struct Unit { static const bool use_unit_diag = true; }; - struct NonUnit { static const bool use_unit_diag = false; }; + struct Team { + static const char *name() { return "Team"; } }; + }; - struct Mode { - struct Serial { - static const char *name() { return "Serial"; } + struct Algo { + struct Level3 { + struct Unblocked { + static const char* name() { return "Unblocked"; } }; - struct Team { - static const char *name() { return "Team"; } - }; - }; - - struct Algo { - struct Level3 { - struct Unblocked { - static const char* name() { return "Unblocked"; } - }; - struct Blocked { - static const char* name() { return "Blocked"; } - // TODO:: for now harwire the blocksizes; this should reflect - // regieter blocking (not about team parallelism). - // this mb should vary according to - // - team policy (smaller) or range policy (bigger) - // - space (cuda vs host) - // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. + struct Blocked { + static const char* name() { return "Blocked"; } + // TODO:: for now harwire the blocksizes; this should reflect + // regieter blocking (not about team parallelism). + // this mb should vary according to + // - team policy (smaller) or range policy (bigger) + // - space (cuda vs host) + // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. #if defined(KOKKOS_ENABLE_CUDA) - template KOKKOS_INLINE_FUNCTION static constexpr - typename std::enable_if::value,int> - ::type mb() { return 2; } + template KOKKOS_INLINE_FUNCTION static constexpr + typename std::enable_if::value,int> + ::type mb() { return 2; } #endif - template KOKKOS_INLINE_FUNCTION static constexpr - typename std::enable_if::value,int> - ::type mb() { return 4; } - }; - struct MKL { - static const char* name() { return "MKL"; } - }; - struct CompactMKL { - static const char* name() { return "CompactMKL"; } - }; + template KOKKOS_INLINE_FUNCTION static constexpr + typename std::enable_if::value,int> + ::type mb() { return 4; } + }; + struct MKL { + static const char* name() { return "MKL"; } }; + struct CompactMKL { + static const char* name() { return "CompactMKL"; } + }; + }; - using Gemm = Level3; - using Trsm = Level3; - using LU = Level3; - using InverseLU = Level3; - using SolveLU = Level3; - - struct Level2 { - struct Unblocked {}; - struct Blocked { - // TODO:: for now harwire the blocksizes; this should reflect - // regieter blocking (not about team parallelism). - // this mb should vary according to - // - team policy (smaller) or range policy (bigger) - // - space (cuda vs host) - // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. + using Gemm = Level3; + using Trsm = Level3; + using LU = Level3; + using InverseLU = Level3; + using SolveLU = Level3; + + struct Level2 { + struct Unblocked {}; + struct Blocked { + // TODO:: for now harwire the blocksizes; this should reflect + // regieter blocking (not about team parallelism). + // this mb should vary according to + // - team policy (smaller) or range policy (bigger) + // - space (cuda vs host) + // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. #if defined(KOKKOS_ENABLE_CUDA) - template KOKKOS_INLINE_FUNCTION static constexpr - typename std::enable_if::value,int> - ::type mb() { return 1; } + template KOKKOS_INLINE_FUNCTION static constexpr + typename std::enable_if::value,int> + ::type mb() { return 1; } #endif - template KOKKOS_INLINE_FUNCTION static constexpr - typename std::enable_if::value,int> - ::type mb() { return 4; } - }; - struct MKL {}; - struct CompactMKL {}; + template KOKKOS_INLINE_FUNCTION static constexpr + typename std::enable_if::value,int> + ::type mb() { return 4; } }; + struct MKL {}; + struct CompactMKL {}; + }; - using Gemv = Level2; - using Trsv = Level2; - - // struct Level1 { - // struct Unblocked {}; - // struct Blocked { - // // TODO:: for now harwire the blocksizes; this should reflect - // // regieter blocking (not about team parallelism). - // // this mb should vary according to - // // - team policy (smaller) or range policy (bigger) - // // - space (cuda vs host) - // // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. - // #if defined(KOKKOS_ENABLE_CUDA) - // template KOKKOS_INLINE_FUNCTION static constexpr - // typename std::enable_if::value,int> - // ::type mb() { return 4; } - // #endif - // template KOKKOS_INLINE_FUNCTION static constexpr - // typename std::enable_if::value,int> - // ::type mb() { return 4; } - // }; - // //struct MKL {}; - // //struct CompactMKL {}; - // }; + using Gemv = Level2; + using Trsv = Level2; + + // struct Level1 { + // struct Unblocked {}; + // struct Blocked { + // // TODO:: for now harwire the blocksizes; this should reflect + // // regieter blocking (not about team parallelism). + // // this mb should vary according to + // // - team policy (smaller) or range policy (bigger) + // // - space (cuda vs host) + // // - blocksize input (blk <= 4 mb = 2, otherwise mb = 4), etc. + // #if defined(KOKKOS_ENABLE_CUDA) + // template KOKKOS_INLINE_FUNCTION static constexpr + // typename std::enable_if::value,int> + // ::type mb() { return 4; } + // #endif + // template KOKKOS_INLINE_FUNCTION static constexpr + // typename std::enable_if::value,int> + // ::type mb() { return 4; } + // }; + // //struct MKL {}; + // //struct CompactMKL {}; + // }; + + }; + + struct Util { - }; + template + KOKKOS_INLINE_FUNCTION + static void + packColMajor(ValueType *__restrict__ A, + const int m, + const int n, + const ValueType *__restrict__ B, + const int bs0, + const int bs1) { + for (int j=0;j - KOKKOS_INLINE_FUNCTION - static void - packColMajor(ValueType *__restrict__ A, - const int m, - const int n, - const ValueType *__restrict__ B, - const int bs0, - const int bs1) { - for (int j=0;j - KOKKOS_INLINE_FUNCTION - static void - packRowMajor(ValueType *__restrict__ A, - const int m, - const int n, - const ValueType *__restrict__ B, - const int bs0, - const int bs1) { - for (int i=0;i + KOKKOS_INLINE_FUNCTION + static void + packRowMajor(ValueType *__restrict__ A, + const int m, + const int n, + const ValueType *__restrict__ B, + const int bs0, + const int bs1) { + for (int i=0;i struct Partition1x2; - template struct Partition1x3; + template struct Partition1x2; + template struct Partition1x3; - template - struct Partition1x2 { - const int as1; - ValueType *AL, *AR; - - KOKKOS_INLINE_FUNCTION - Partition1x2(const int arg_as1) - : as1(arg_as1), AL(NULL), AR(NULL) {} - - KOKKOS_INLINE_FUNCTION - void partWithAL(ValueType *A, const int nA, const int nAL) { - AL = A; AR = AL+nAL*as1; - } - - KOKKOS_INLINE_FUNCTION - void partWithAR(ValueType *A, const int nA, const int nAR) { - AL = A; AR = AL+(nA-nAR)*as1; - } - - // A0 A1 are merged into AL - KOKKOS_INLINE_FUNCTION - void mergeToAL(const Partition1x3 &part) { - AL = part.A0; AR = part.A2; - } - - // A0 A1 are merged into AL - KOKKOS_INLINE_FUNCTION - void mergeToAR(const Partition1x3 &part) { - AL = part.A0; AR = part.A1; - } - }; + template + struct Partition1x2 { + const int as1; + ValueType *AL, *AR; - template - struct Partition1x3 { - const int as1; - ValueType *A0, *A1, *A2; - - KOKKOS_INLINE_FUNCTION - Partition1x3(const int arg_as1) - : as1(arg_as1), A0(NULL), A1(NULL), A2(NULL) {} - - KOKKOS_INLINE_FUNCTION - void partWithAL(const Partition1x2 &part, const int mA1) { - A0 = part.AL; A2 = part.AR; A1 = A2 - mA1*as1; - } - KOKKOS_INLINE_FUNCTION - void partWithAR(const Partition1x2 &part, const int mA1) { - A0 = part.AL; A1 = part.AR; A2 = A1 + mA1*as1; - } - }; + KOKKOS_INLINE_FUNCTION + Partition1x2(const int arg_as1) + : as1(arg_as1), AL(NULL), AR(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAL(ValueType *A, const int nA, const int nAL) { + AL = A; AR = AL+nAL*as1; + } + + KOKKOS_INLINE_FUNCTION + void partWithAR(ValueType *A, const int nA, const int nAR) { + AL = A; AR = AL+(nA-nAR)*as1; + } + + // A0 A1 are merged into AL + KOKKOS_INLINE_FUNCTION + void mergeToAL(const Partition1x3 &part) { + AL = part.A0; AR = part.A2; + } + + // A0 A1 are merged into AL + KOKKOS_INLINE_FUNCTION + void mergeToAR(const Partition1x3 &part) { + AL = part.A0; AR = part.A1; + } + }; + + template + struct Partition1x3 { + const int as1; + ValueType *A0, *A1, *A2; + + KOKKOS_INLINE_FUNCTION + Partition1x3(const int arg_as1) + : as1(arg_as1), A0(NULL), A1(NULL), A2(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAL(const Partition1x2 &part, const int mA1) { + A0 = part.AL; A2 = part.AR; A1 = A2 - mA1*as1; + } + KOKKOS_INLINE_FUNCTION + void partWithAR(const Partition1x2 &part, const int mA1) { + A0 = part.AL; A1 = part.AR; A2 = A1 + mA1*as1; + } + }; - template struct Partition2x1; - template struct Partition3x1; + template struct Partition2x1; + template struct Partition3x1; - template - struct Partition2x1 { - const int as0; - ValueType *AT, *AB; - - KOKKOS_INLINE_FUNCTION - Partition2x1(const int arg_as0) - : as0(arg_as0), AT(NULL), AB(NULL) {} - - KOKKOS_INLINE_FUNCTION - void partWithAT(ValueType *A, const int mA, const int mAT) { - AT = A; - AB = AT+mAT*as0; - } - - KOKKOS_INLINE_FUNCTION - void partWithAB(ValueType *A, const int mA, const int mAB) { - partWithAT(A, mA, mA-mAB); - } - - // A0 - // A1 is merged into AT - KOKKOS_INLINE_FUNCTION - void mergeToAT(const Partition3x1 &part) { - AT = part.A0; - AB = part.A2; - } - - KOKKOS_INLINE_FUNCTION - void mergeToAB(const Partition3x1 &part) { - AT = part.A0; - AB = part.A1; - } - }; + template + struct Partition2x1 { + const int as0; + ValueType *AT, *AB; - template - struct Partition3x1 { - const int as0; - ValueType *A0, - /* */ *A1, - /* */ *A2; + KOKKOS_INLINE_FUNCTION + Partition2x1(const int arg_as0) + : as0(arg_as0), AT(NULL), AB(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithAT(ValueType *A, const int mA, const int mAT) { + AT = A; + AB = AT+mAT*as0; + } + + KOKKOS_INLINE_FUNCTION + void partWithAB(ValueType *A, const int mA, const int mAB) { + partWithAT(A, mA, mA-mAB); + } + + // A0 + // A1 is merged into AT + KOKKOS_INLINE_FUNCTION + void mergeToAT(const Partition3x1 &part) { + AT = part.A0; + AB = part.A2; + } + + KOKKOS_INLINE_FUNCTION + void mergeToAB(const Partition3x1 &part) { + AT = part.A0; + AB = part.A1; + } + }; + + template + struct Partition3x1 { + const int as0; + ValueType *A0, + /* */ *A1, + /* */ *A2; - KOKKOS_INLINE_FUNCTION - Partition3x1(const int arg_as0) - : as0(arg_as0), - A0(NULL), - A1(NULL), - A2(NULL) {} + KOKKOS_INLINE_FUNCTION + Partition3x1(const int arg_as0) + : as0(arg_as0), + A0(NULL), + A1(NULL), + A2(NULL) {} - KOKKOS_INLINE_FUNCTION - void partWithAB(const Partition2x1 &part, const int mA1) { - A0 = part.AT; - A1 = part.AB; - A2 = A1 + mA1*as0; - } - - KOKKOS_INLINE_FUNCTION - void partWithAT(const Partition2x1 &part, const int mA1) { - A0 = part.AT; - A1 = part.AB - mA1*as0; - A2 = part.AB; - } - }; + KOKKOS_INLINE_FUNCTION + void partWithAB(const Partition2x1 &part, const int mA1) { + A0 = part.AT; + A1 = part.AB; + A2 = A1 + mA1*as0; + } - template struct Partition2x2; - template struct Partition3x3; + KOKKOS_INLINE_FUNCTION + void partWithAT(const Partition2x1 &part, const int mA1) { + A0 = part.AT; + A1 = part.AB - mA1*as0; + A2 = part.AB; + } + }; - template - struct Partition2x2 { - const int as0, as1; - ValueType *ATL, *ATR, *ABL, *ABR; - - KOKKOS_INLINE_FUNCTION - Partition2x2(const int arg_as0, const int arg_as1) - : as0(arg_as0), as1(arg_as1), ATL(NULL), ATR(NULL), ABL(NULL), ABR(NULL) {} - - KOKKOS_INLINE_FUNCTION - void partWithATL(ValueType *A, - const int mA, const int nA, - const int mATL, const int nATL) { - ATL = A; ATR = ATL+nATL*as1; - ABL = ATL+mATL*as0; ABR = ABL+nATL*as1; - } - - KOKKOS_INLINE_FUNCTION - void partWithABR(ValueType *A, - const int mA, const int nA, - const int mABR, const int nABR) { - partWithATL(A, mA, nA, mA-mABR, nA-nABR); - } - - // A00 A01 - // A10 A11 is merged into ATL - KOKKOS_INLINE_FUNCTION - void mergeToATL(const Partition3x3 &part) { - ATL = part.A00; ATR = part.A02; - ABL = part.A20; ABR = part.A22; - } - - KOKKOS_INLINE_FUNCTION - void mergeToABR(const Partition3x3 &part) { - ATL = part.A00; ATR = part.A01; - ABL = part.A10; ABR = part.A11; - } - }; + template struct Partition2x2; + template struct Partition3x3; - template - struct Partition3x3 { - const int as0, as1; - ValueType *A00, *A01, *A02, - /* */ *A10, *A11, *A12, - /* */ *A20, *A21, *A22; + template + struct Partition2x2 { + const int as0, as1; + ValueType *ATL, *ATR, *ABL, *ABR; + + KOKKOS_INLINE_FUNCTION + Partition2x2(const int arg_as0, const int arg_as1) + : as0(arg_as0), as1(arg_as1), ATL(NULL), ATR(NULL), ABL(NULL), ABR(NULL) {} + + KOKKOS_INLINE_FUNCTION + void partWithATL(ValueType *A, + const int mA, const int nA, + const int mATL, const int nATL) { + ATL = A; ATR = ATL+nATL*as1; + ABL = ATL+mATL*as0; ABR = ABL+nATL*as1; + } + + KOKKOS_INLINE_FUNCTION + void partWithABR(ValueType *A, + const int mA, const int nA, + const int mABR, const int nABR) { + partWithATL(A, mA, nA, mA-mABR, nA-nABR); + } + + // A00 A01 + // A10 A11 is merged into ATL + KOKKOS_INLINE_FUNCTION + void mergeToATL(const Partition3x3 &part) { + ATL = part.A00; ATR = part.A02; + ABL = part.A20; ABR = part.A22; + } + + KOKKOS_INLINE_FUNCTION + void mergeToABR(const Partition3x3 &part) { + ATL = part.A00; ATR = part.A01; + ABL = part.A10; ABR = part.A11; + } + }; + + template + struct Partition3x3 { + const int as0, as1; + ValueType *A00, *A01, *A02, + /* */ *A10, *A11, *A12, + /* */ *A20, *A21, *A22; - KOKKOS_INLINE_FUNCTION - Partition3x3(const int arg_as0, const int arg_as1) - : as0(arg_as0), as1(arg_as1), - A00(NULL), A01(NULL), A02(NULL), - A10(NULL), A11(NULL), A12(NULL), - A20(NULL), A21(NULL), A22(NULL) {} + KOKKOS_INLINE_FUNCTION + Partition3x3(const int arg_as0, const int arg_as1) + : as0(arg_as0), as1(arg_as1), + A00(NULL), A01(NULL), A02(NULL), + A10(NULL), A11(NULL), A12(NULL), + A20(NULL), A21(NULL), A22(NULL) {} - KOKKOS_INLINE_FUNCTION - void partWithABR(const Partition2x2 &part, const int mA11, const int nA11) { - A00 = part.ATL; A01 = part.ATR; A02 = part.ATR + nA11*as1; - A10 = part.ABL; A11 = part.ABR; A12 = part.ABR + nA11*as1; - A20 = part.ABL + mA11*as0; A21 = part.ABR + mA11*as0; A22 = part.ABR + mA11*as0 + nA11*as1; - } - - KOKKOS_INLINE_FUNCTION - void partWithATL(const Partition2x2 &part, const int mA11, const int nA11) { - A00 = part.ATL; A01 = part.ATR - nA11*as1; A02 = part.ATR; - A10 = part.ABL - mA11*as0; A11 = part.ABR - mA11*as0 - nA11*as1; A12 = part.ABR - mA11*as0; - A20 = part.ABL; A21 = part.ABR - nA11*as1; A22 = part.ABR; - } - }; + KOKKOS_INLINE_FUNCTION + void partWithABR(const Partition2x2 &part, const int mA11, const int nA11) { + A00 = part.ATL; A01 = part.ATR; A02 = part.ATR + nA11*as1; + A10 = part.ABL; A11 = part.ABR; A12 = part.ABR + nA11*as1; + A20 = part.ABL + mA11*as0; A21 = part.ABR + mA11*as0; A22 = part.ABR + mA11*as0 + nA11*as1; + } + + KOKKOS_INLINE_FUNCTION + void partWithATL(const Partition2x2 &part, const int mA11, const int nA11) { + A00 = part.ATL; A01 = part.ATR - nA11*as1; A02 = part.ATR; + A10 = part.ABL - mA11*as0; A11 = part.ABR - mA11*as0 - nA11*as1; A12 = part.ABR - mA11*as0; + A20 = part.ABL; A21 = part.ABR - nA11*as1; A22 = part.ABR; + } + }; - } } + #endif diff --git a/src/batched/KokkosBatched_Vector.hpp b/src/batched/KokkosBatched_Vector.hpp index b3d5fb29af..fe711444f7 100644 --- a/src/batched/KokkosBatched_Vector.hpp +++ b/src/batched/KokkosBatched_Vector.hpp @@ -8,152 +8,151 @@ // forward declaration namespace KokkosBatched { - namespace Experimental { - template - class Vector; - template - struct is_vector,l> > : public std::true_type {}; + template + class Vector; - template - struct DefaultVectorLength { - enum : int { value = 1 }; - }; + template + struct is_vector,l> > : public std::true_type {}; + + template + struct DefaultVectorLength { + enum : int { value = 1 }; + }; - template<> - struct DefaultVectorLength { + template<> + struct DefaultVectorLength { #if defined(__AVX512F__) - enum : int { value = 16 }; + enum : int { value = 16 }; #elif defined(__AVX__) || defined(__AVX2__) - enum : int { value = 8 }; + enum : int { value = 8 }; #else - enum : int { value = 16 }; + enum : int { value = 16 }; #endif - }; - template<> - struct DefaultVectorLength { + }; + template<> + struct DefaultVectorLength { #if defined(__AVX512F__) - enum : int { value = 8 }; + enum : int { value = 8 }; #elif defined(__AVX__) || defined(__AVX2__) - enum : int { value = 4 }; + enum : int { value = 4 }; #else - enum : int { value = 8 }; + enum : int { value = 8 }; #endif - }; - template<> - struct DefaultVectorLength,Kokkos::HostSpace> { + }; + template<> + struct DefaultVectorLength,Kokkos::HostSpace> { #if defined(__AVX512F__) - enum : int { value = 8 }; + enum : int { value = 8 }; #elif defined(__AVX__) || defined(__AVX2__) - enum : int { value = 4 }; + enum : int { value = 4 }; #else - enum : int { value = 8 }; + enum : int { value = 8 }; #endif - }; - template<> - struct DefaultVectorLength,Kokkos::HostSpace> { + }; + template<> + struct DefaultVectorLength,Kokkos::HostSpace> { #if defined(__AVX512F__) - enum : int { value = 4 }; + enum : int { value = 4 }; #elif defined(__AVX__) || defined(__AVX2__) - enum : int { value = 2 }; + enum : int { value = 2 }; #else - enum : int { value = 4 }; + enum : int { value = 4 }; #endif - }; + }; #if defined(KOKKOS_ENABLE_CUDA) - template<> - struct DefaultVectorLength { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength,Kokkos::CudaSpace> { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength,Kokkos::CudaSpace> { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 16 }; - }; - template<> - struct DefaultVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 16 }; - }; + template<> + struct DefaultVectorLength { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength,Kokkos::CudaSpace> { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength,Kokkos::CudaSpace> { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 16 }; + }; + template<> + struct DefaultVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 16 }; + }; #endif - template - struct DefaultInternalVectorLength { - enum : int { value = 1 }; - }; - template - struct DefaultInternalVectorLength { - enum : int { value = DefaultVectorLength::value }; - }; + template + struct DefaultInternalVectorLength { + enum : int { value = 1 }; + }; + template + struct DefaultInternalVectorLength { + enum : int { value = DefaultVectorLength::value }; + }; #if defined(KOKKOS_ENABLE_CUDA) - template<> - struct DefaultInternalVectorLength { - enum : int { value = 4 }; - }; - template<> - struct DefaultInternalVectorLength { - enum : int { value = 2 }; - }; - template<> - struct DefaultInternalVectorLength,Kokkos::CudaSpace> { - enum : int { value = 2 }; - }; - template<> - struct DefaultInternalVectorLength,Kokkos::CudaSpace> { - enum : int { value = 1 }; - }; - template<> - struct DefaultInternalVectorLength { - enum : int { value = 4 }; - }; - template<> - struct DefaultInternalVectorLength { - enum : int { value = 2 }; - }; - template<> - struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 2 }; - }; - template<> - struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 1 }; - }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 4 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaSpace> { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaSpace> { + enum : int { value = 1 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 4 }; + }; + template<> + struct DefaultInternalVectorLength { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 2 }; + }; + template<> + struct DefaultInternalVectorLength,Kokkos::CudaUVMSpace> { + enum : int { value = 1 }; + }; #endif - template - struct MagnitudeScalarType; + template + struct MagnitudeScalarType; - template<> struct MagnitudeScalarType { typedef float type; }; - template<> struct MagnitudeScalarType { typedef double type; }; - template<> struct MagnitudeScalarType > { typedef float type; }; - template<> struct MagnitudeScalarType > { typedef double type; }; + template<> struct MagnitudeScalarType { typedef float type; }; + template<> struct MagnitudeScalarType { typedef double type; }; + template<> struct MagnitudeScalarType > { typedef float type; }; + template<> struct MagnitudeScalarType > { typedef double type; }; - template struct MagnitudeScalarType,l> > { typedef float type; }; - template struct MagnitudeScalarType,l> > { typedef double type; }; - template struct MagnitudeScalarType >,l> > { typedef float type; }; - template struct MagnitudeScalarType >,l> > { typedef double type; }; + template struct MagnitudeScalarType,l> > { typedef float type; }; + template struct MagnitudeScalarType,l> > { typedef double type; }; + template struct MagnitudeScalarType >,l> > { typedef float type; }; + template struct MagnitudeScalarType >,l> > { typedef double type; }; - } } #include "KokkosBatched_Vector_SIMD.hpp" @@ -165,13 +164,13 @@ namespace Kokkos { // do not use Vector alone as other can use the name. template - class ArithTraits,l> > { + class ArithTraits,l> > { public: typedef typename ArithTraits::val_type val_scalar_type; typedef typename ArithTraits::mag_type mag_scalar_type; - typedef KokkosBatched::Experimental::Vector,l> val_type; - typedef KokkosBatched::Experimental::Vector,l> mag_type; + typedef KokkosBatched::Vector,l> val_type; + typedef KokkosBatched::Vector,l> mag_type; static KOKKOS_FORCEINLINE_FUNCTION mag_type real (const val_type &val) { return val; @@ -186,13 +185,13 @@ namespace Kokkos { template - class ArithTraits>,l> > { + class ArithTraits>,l> > { public: typedef typename ArithTraits::val_type val_scalar_type; typedef typename ArithTraits::mag_type mag_scalar_type; - typedef KokkosBatched::Experimental::Vector >,l> val_type; - typedef KokkosBatched::Experimental::Vector,l> mag_type; + typedef KokkosBatched::Vector >,l> val_type; + typedef KokkosBatched::Vector,l> mag_type; static KOKKOS_FORCEINLINE_FUNCTION mag_type real (const val_type &val) { mag_type r_val; diff --git a/src/batched/KokkosBatched_Vector_AVX256D.hpp b/src/batched/KokkosBatched_Vector_AVX256D.hpp index 915d4ffefe..0284537ffd 100644 --- a/src/batched/KokkosBatched_Vector_AVX256D.hpp +++ b/src/batched/KokkosBatched_Vector_AVX256D.hpp @@ -8,7 +8,7 @@ #include namespace KokkosBatched { - namespace Experimental { + { /// /// AVX256D double diff --git a/src/batched/KokkosBatched_Vector_AVX512D.hpp b/src/batched/KokkosBatched_Vector_AVX512D.hpp index 9db3d4c4e1..591ba09f01 100644 --- a/src/batched/KokkosBatched_Vector_AVX512D.hpp +++ b/src/batched/KokkosBatched_Vector_AVX512D.hpp @@ -7,7 +7,7 @@ #include namespace KokkosBatched { - namespace Experimental { + { /// /// AVX512D double /// diff --git a/src/batched/KokkosBatched_Vector_SIMD.hpp b/src/batched/KokkosBatched_Vector_SIMD.hpp index 1796b493c1..388519c772 100644 --- a/src/batched/KokkosBatched_Vector_SIMD.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD.hpp @@ -14,212 +14,208 @@ #endif namespace KokkosBatched { - namespace Experimental { - - template - struct TypeTraits { - typedef T thread_private_type; - typedef T team_private_type; - }; - - template - struct TypeTraits,l>, v> { - typedef typename std::conditional::value, - Vector,l>, T>::type thread_private_type; - typedef typename std::conditional::value, - Vector,l>, Vector,(l/v)+(l%v>0)> > team_private_type; - }; + + template + struct TypeTraits { + typedef T thread_private_type; + typedef T team_private_type; + }; + + template + struct TypeTraits,l>, v> { + typedef typename std::conditional::value, + Vector,l>, T>::type thread_private_type; + typedef typename std::conditional::value, + Vector,l>, Vector,(l/v)+(l%v>0)> > team_private_type; + }; - template - class Vector,l> { - public: - using type = Vector,l>; - using value_type = T; - using mag_type = typename Kokkos::Details::ArithTraits::mag_type; + template + class Vector,l> { + public: + using type = Vector,l>; + using value_type = T; + using mag_type = typename Kokkos::Details::ArithTraits::mag_type; - enum : int { vector_length = l }; + enum : int { vector_length = l }; #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) - typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; + typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; #else - typedef value_type data_type[vector_length]; + typedef value_type data_type[vector_length]; #endif - KOKKOS_INLINE_FUNCTION - static const char* label() { return "SIMD"; } + KOKKOS_INLINE_FUNCTION + static const char* label() { return "SIMD"; } - template - friend class Vector; + template + friend class Vector; - private: - mutable data_type _data; + private: + mutable data_type _data; - public: - KOKKOS_INLINE_FUNCTION Vector() { - //static_assert(std::is_same::value, - // "Vector SIMD should not be instanciated in CudaSpace"); + public: + KOKKOS_INLINE_FUNCTION Vector() { + //static_assert(std::is_same::value, + // "Vector SIMD should not be instanciated in CudaSpace"); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + for (int i=0;i + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + for (int i=0;i + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - class Vector,2> { - public: - using type = Vector,2>; - using value_type = double; - using mag_type = double; - - enum : int { vector_length = 2 }; - //typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; - typedef double2 data_type; - - KOKKOS_INLINE_FUNCTION - static const char* label() { return "CudaDouble2"; } - - template - friend class Vector; - - private: - mutable data_type _data; - - public: - KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; } - KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; } - KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; } - KOKKOS_INLINE_FUNCTION Vector(const double2 &val) { _data.x = val.x; _data.y = val.y; } - - template - KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { - _data.x = val; - _data.y = val; - } - - template - KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { - _data.x = b[0]; - _data.y = b[1]; - } - - KOKKOS_INLINE_FUNCTION - type& operator=(const double2 &val) { - _data.x = val.x; - _data.y = val.y; - return *this; - } - - KOKKOS_INLINE_FUNCTION - double2 double2() const { - return _data; - } - - KOKKOS_INLINE_FUNCTION - type& loadAligned(const value_type *p) { - _data.x = *(p ); - _data.y = *(p+1); - return *this; - } - - KOKKOS_INLINE_FUNCTION - type& loadUnaligned(const value_type *p) { - _data.x = *(p ); - _data.y = *(p+1); - return *this; - } - - KOKKOS_INLINE_FUNCTION - void storeAligned(value_type *p) const { - *(p ) = _data.x; - *(p+1) = _data.y; - } - - KOKKOS_INLINE_FUNCTION - void storeUnaligned(value_type *p) const { - *(p ) = _data.x; - *(p+1) = _data.y; - } - - KOKKOS_INLINE_FUNCTION - value_type& operator[](const int &i) const { - return reinterpret_cast(&_data)[i]; - } - }; - } + + template<> + class Vector,2> { + public: + using type = Vector,2>; + using value_type = double; + using mag_type = double; + + enum : int { vector_length = 2 }; + //typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; + typedef double2 data_type; + + KOKKOS_INLINE_FUNCTION + static const char* label() { return "CudaDouble2"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; } + KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; } + KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; } + KOKKOS_INLINE_FUNCTION Vector(const double2 &val) { _data.x = val.x; _data.y = val.y; } + + template + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + _data.x = val; + _data.y = val; + } + + template + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + _data.x = b[0]; + _data.y = b[1]; + } + + KOKKOS_INLINE_FUNCTION + type& operator=(const double2 &val) { + _data.x = val.x; + _data.y = val.y; + return *this; + } + + KOKKOS_INLINE_FUNCTION + double2 double2() const { + return _data; + } + + KOKKOS_INLINE_FUNCTION + type& loadAligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + type& loadUnaligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + void storeAligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + void storeUnaligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + value_type& operator[](const int &i) const { + return reinterpret_cast(&_data)[i]; + } + }; } #endif @@ -229,380 +225,378 @@ namespace KokkosBatched { #include namespace KokkosBatched { - namespace Experimental { - template<> - class Vector,4> { - public: - using type = Vector,4>; - using value_type = double; - using mag_type = double; + template<> + class Vector,4> { + public: + using type = Vector,4>; + using value_type = double; + using mag_type = double; - enum : int { vector_length = 4 }; - typedef __m256d data_type __attribute__ ((aligned(32))); + enum : int { vector_length = 4 }; + typedef __m256d data_type __attribute__ ((aligned(32))); - inline - static const char* label() { return "AVX256"; } + inline + static const char* label() { return "AVX256"; } - template - friend class Vector; + template + friend class Vector; - private: - mutable data_type _data; + private: + mutable data_type _data; - public: - inline Vector() { _data = _mm256_setzero_pd(); } - inline Vector(const value_type &val) { _data = _mm256_set1_pd(val); } - inline Vector(const type &b) { _data = b._data; } - inline Vector(const __m256d &val) { _data = val; } + public: + inline Vector() { _data = _mm256_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm256_set1_pd(val); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m256d &val) { _data = val; } - template - inline Vector(const ArgValueType &val) { - auto d = reinterpret_cast(&_data); + template + inline Vector(const ArgValueType &val) { + auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - inline Vector(const Vector,vector_length> &b) { - auto dd = reinterpret_cast(&_data); - auto bb = reinterpret_cast(&b._data); + for (int i=0;i + inline Vector(const Vector,vector_length> &b) { + auto dd = reinterpret_cast(&_data); + auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i(&_data)[i]; - } - }; - - template<> - class Vector >,2> { - public: - using type = Vector >,2>; - using value_type = Kokkos::complex; - using mag_type = double; - - static const int vector_length = 2; - typedef __m256d data_type __attribute__ ((aligned(32))); - - inline - static const char* label() { return "AVX256"; } + for (int i=0;i(&_data)[i]; + } + }; + + template<> + class Vector >,2> { + public: + using type = Vector >,2>; + using value_type = Kokkos::complex; + using mag_type = double; + + static const int vector_length = 2; + typedef __m256d data_type __attribute__ ((aligned(32))); + + inline + static const char* label() { return "AVX256"; } - template - friend class Vector; - - private: - mutable data_type _data; - - public: - inline Vector() { _data = _mm256_setzero_pd(); } - inline Vector(const value_type &val) { _data = _mm256_broadcast_pd((const __m128d *)&val);} - inline Vector(const mag_type &val) { const value_type a(val); _data = _mm256_broadcast_pd((__m128d const *)&a); } - inline Vector(const type &b) { _data = b._data; } - inline Vector(const __m256d &val) { _data = val; } + template + friend class Vector; + + private: + mutable data_type _data; + + public: + inline Vector() { _data = _mm256_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm256_broadcast_pd((const __m128d *)&val);} + inline Vector(const mag_type &val) { const value_type a(val); _data = _mm256_broadcast_pd((__m128d const *)&a); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m256d &val) { _data = val; } -// template -// inline Vector(const ArgValueType val) { -// #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) -// #pragma ivdep -// #endif -// #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) -// #pragma vector always -// #endif -// for (int i=0;i - inline Vector(const Vector,vector_length> &b) { - auto dd = reinterpret_cast(&_data); - auto bb = reinterpret_cast(&b._data); + // template + // inline Vector(const ArgValueType val) { + // #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) + // #pragma ivdep + // #endif + // #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) + // #pragma vector always + // #endif + // for (int i=0;i + inline Vector(const Vector,vector_length> &b) { + auto dd = reinterpret_cast(&_data); + auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i(&_data)[i]; - } - }; -}} + for (int i=0;i(&_data)[i]; + } + }; +} #endif /* #if defined(__AVX__) || defined(__AVX2__) */ #if defined(__AVX512F__) #include namespace KokkosBatched { - namespace Experimental { - - template<> - class Vector,8> { - public: - using type = Vector,8>; - using value_type = double; - using mag_type = double; + + template<> + class Vector,8> { + public: + using type = Vector,8>; + using value_type = double; + using mag_type = double; - enum : int { vector_length = 8 }; - typedef __m512d data_type __attribute__ ((aligned(64))); + enum : int { vector_length = 8 }; + typedef __m512d data_type __attribute__ ((aligned(64))); - template - friend class Vector; + template + friend class Vector; - private: - mutable data_type _data; + private: + mutable data_type _data; - public: - inline Vector() { _data = _mm512_setzero_pd(); } - inline Vector(const value_type &val) { _data = _mm512_set1_pd(val); } - inline Vector(const type &b) { _data = b._data; } - inline Vector(const __m512d &val) { _data = val; } + public: + inline Vector() { _data = _mm512_setzero_pd(); } + inline Vector(const value_type &val) { _data = _mm512_set1_pd(val); } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m512d &val) { _data = val; } - template - inline Vector(const ArgValueType &val) { - auto d = reinterpret_cast(&_data); + template + inline Vector(const ArgValueType &val) { + auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - inline Vector(const Vector,vector_length> &b) { - auto dd = reinterpret_cast(&_data); - auto bb = reinterpret_cast(&b._data); + for (int i=0;i + inline Vector(const Vector,vector_length> &b) { + auto dd = reinterpret_cast(&_data); + auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i(&_data)[i]; - } - }; - - template<> - class Vector >,4> { - public: - using type = Vector >,4>; - using value_type = Kokkos::complex; - using mag_type = double; - - enum : int { vector_length = 4 }; - typedef __m512d data_type __attribute__ ((aligned(64))); - - inline - static const char* label() { return "AVX512"; } - - template - friend class Vector; - - private: - mutable data_type _data; - - public: - inline Vector() { _data = _mm512_setzero_pd(); } - inline Vector(const value_type &val) { - _data = _mm512_mask_broadcast_f64x4(_mm512_set1_pd(val.imag()), 0x55, _mm256_set1_pd(val.real())); - } - inline Vector(const mag_type &val) { - _data = _mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, _mm256_set1_pd(val)); - } - inline Vector(const type &b) { _data = b._data; } - inline Vector(const __m512d &val) { _data = val; } - - template - inline Vector(const ArgValueType &val) { - auto d = reinterpret_cast(&_data); + for (int i=0;i(&_data)[i]; + } + }; + + template<> + class Vector >,4> { + public: + using type = Vector >,4>; + using value_type = Kokkos::complex; + using mag_type = double; + + enum : int { vector_length = 4 }; + typedef __m512d data_type __attribute__ ((aligned(64))); + + inline + static const char* label() { return "AVX512"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + inline Vector() { _data = _mm512_setzero_pd(); } + inline Vector(const value_type &val) { + _data = _mm512_mask_broadcast_f64x4(_mm512_set1_pd(val.imag()), 0x55, _mm256_set1_pd(val.real())); + } + inline Vector(const mag_type &val) { + _data = _mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, _mm256_set1_pd(val)); + } + inline Vector(const type &b) { _data = b._data; } + inline Vector(const __m512d &val) { _data = val; } + + template + inline Vector(const ArgValueType &val) { + auto d = reinterpret_cast(&_data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - inline Vector(const Vector,vector_length> &b) { - auto dd = reinterpret_cast(&_data); - auto bb = reinterpret_cast(&b._data); + for (int i=0;i + inline Vector(const Vector,vector_length> &b) { + auto dd = reinterpret_cast(&_data); + auto bb = reinterpret_cast(&b._data); #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i(&_data)[i]; - } - }; - } + for (int i=0;i(&_data)[i]; + } + }; } + #endif /* #if defined(__AVX512F__) */ #endif /* #if defined(__KOKKOSBATCHED_ENABLE_AVX__) */ diff --git a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp index f912a777e5..28826abf66 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp @@ -6,843 +6,842 @@ #include "Kokkos_Complex.hpp" namespace KokkosBatched { - namespace Experimental { - //#define KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(A) typename std::enable_if::value,A >::type + //#define KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(A) typename std::enable_if::value,A >::type #define KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) Vector< SIMD< T >, l > #define KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) Vector< SIMD < T >, l> & - /// simd, simd + /// simd, simd #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) operator + (const Vector,8> &a, const Vector,8> &b) { - return _mm512_add_pd(a, b); - } + return _mm512_add_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator + (const Vector >,4> &a, const Vector >,4> &b) { - return _mm512_add_pd(a, b); - } + return _mm512_add_pd(a, b); + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator + (const Vector,4> & a, const Vector,4> & b) { - return _mm256_add_pd(a, b); - } + return _mm256_add_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) operator + (const Vector >,2> & a, const Vector >,2> & b) { - return _mm256_add_pd(a, b); - } + return _mm256_add_pd(a, b); + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator + (const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x + b.double2().x; - r_val.y = a.double2().y + b.double2().y; - return r_val; - } + double2 r_val; + r_val.x = a.double2().x + b.double2().x; + r_val.y = a.double2().y + b.double2().y; + return r_val; + } #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator += (Vector,l> &a, const Vector,l> &b) { - a = a + b; - return a; - } + a = a + b; + return a; + } - /// simd, real + /// simd, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator + (const Vector,l> &a, const T b) { - return a + Vector,l>(b); - } + return a + Vector,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator + (const T a, const Vector,l> &b) { - return Vector,l>(a) + b; - } + return Vector,l>(a) + b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator += (Vector,l> &a, const T b) { - a = a + b; - return a; - } - - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + a = a + b; + return a; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator ++ (Vector,l> &a, int) { - Vector,l> a0 = a; - a = a + typename Kokkos::Details::ArithTraits::mag_type(1); - return a0; - } - - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + Vector,l> a0 = a; + a = a + typename Kokkos::Details::ArithTraits::mag_type(1); + return a0; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator ++ (Vector,l> &a) { - a = a + typename Kokkos::Details::ArithTraits::mag_type(1); - return a; - } + a = a + typename Kokkos::Details::ArithTraits::mag_type(1); + return a; + } - /// simd complex, real + /// simd complex, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator + (const Vector >,l> &a, const T b) { - return a + Vector >,l>(b); - } + return a + Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator + (const T a, const Vector >,l> &b) { - return Vector >,l>(a) + b; - } + return Vector >,l>(a) + b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator += (Vector >,l> &a, const T b) { - a = a + b; - return a; - } + a = a + b; + return a; + } - /// simd complex, complex + /// simd complex, complex - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator + (const Vector >,l> &a, const Kokkos::complex b) { - return a + Vector >,l>(b); - } + return a + Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator + (const Kokkos::complex a, const Vector >,l> &b) { - return Vector >,l>(a) + b; - } + return Vector >,l>(a) + b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator += (Vector >,l> &a, const Kokkos::complex b) { - a = a + b; - return a; - } + a = a + b; + return a; + } - /// --------------------------------------------------------------------------------------------------- + /// --------------------------------------------------------------------------------------------------- - /// simd, simd + /// simd, simd #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) operator - (const Vector,8> &a, const Vector,8> &b) { - return _mm512_sub_pd(a, b); - } + return _mm512_sub_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator - (const Vector >,4> &a, const Vector >,4> &b) { - return _mm512_sub_pd(a, b); - } + return _mm512_sub_pd(a, b); + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator - (const Vector,4> & a, const Vector,4> & b) { - return _mm256_sub_pd(a, b); - } + return _mm256_sub_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) operator - (const Vector >,2> & a, const Vector >,2> & b) { - return _mm256_sub_pd(a, b); - } + return _mm256_sub_pd(a, b); + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator - (const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x - b.double2().x; - r_val.y = a.double2().y - b.double2().y; - return r_val; - } + double2 r_val; + r_val.x = a.double2().x - b.double2().x; + r_val.y = a.double2().y - b.double2().y; + return r_val; + } #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator - (const Vector,l> &a) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator -= (Vector,l> &a, const Vector,l> &b) { - a = a - b; - return a; - } + a = a - b; + return a; + } - /// simd, real + /// simd, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator - (const Vector,l> &a, const T b) { - return a - Vector,l>(b); - } + return a - Vector,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator - (const T a, const Vector,l> &b) { - return Vector,l>(a) - b; - } + return Vector,l>(a) - b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator -= (Vector,l> &a, const T b) { - a = a - b; - return a; - } - - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + a = a - b; + return a; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator -- (Vector,l> &a, int) { - Vector,l> a0 = a; - a = a - typename Kokkos::Details::ArithTraits::mag_type(1); - return a0; - } - - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + Vector,l> a0 = a; + a = a - typename Kokkos::Details::ArithTraits::mag_type(1); + return a0; + } + + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator -- (Vector,l> &a) { - a = a - typename Kokkos::Details::ArithTraits::mag_type(1); - return a; - } + a = a - typename Kokkos::Details::ArithTraits::mag_type(1); + return a; + } - /// simd complex, real + /// simd complex, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator - (const Vector >,l> &a, const T b) { - return a - Vector >,l>(b); - } + return a - Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator - (const T a, const Vector >,l> &b) { - return Vector >,l>(a) - b; - } + return Vector >,l>(a) - b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator -= (Vector >,l> &a, const T b) { - a = a - b; - return a; - } + a = a - b; + return a; + } - /// simd complex, complex + /// simd complex, complex - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator - (const Vector >,l> &a, const Kokkos::complex b) { - return a - Vector >,l>(b); - } + return a - Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator - (const Kokkos::complex a, const Vector >,l> &b) { - return Vector >,l>(a) - b; - } + return Vector >,l>(a) - b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator -= (Vector >,l> &a, const Kokkos::complex b) { - a = a - b; - return a; - } + a = a - b; + return a; + } - /// --------------------------------------------------------------------------------------------------- + /// --------------------------------------------------------------------------------------------------- - /// simd, simd + /// simd, simd #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) operator * (const Vector,8> &a, const Vector,8> &b) { - return _mm512_mul_pd(a, b); - } + return _mm512_mul_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator * (const Vector >,4> &a, const Vector >,4> &b) { - const __m512d - as = _mm512_permute_pd(a, 0x55), - br = _mm512_permute_pd(b, 0x00), - bi = _mm512_permute_pd(b, 0xff); + const __m512d + as = _mm512_permute_pd(a, 0x55), + br = _mm512_permute_pd(b, 0x00), + bi = _mm512_permute_pd(b, 0xff); #if defined(__FMA__) - // latency 7, throughput 0.5 - return _mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)); + // latency 7, throughput 0.5 + return _mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)); #else - return _mm512_add_pd(_mm512_mul_pd(a, br), - _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, - _mm256_set1_pd(-0.0)))))); - // const __mm512d cc = _mm512_mul_pd(as, bi); - // return _mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc); + return _mm512_add_pd(_mm512_mul_pd(a, br), + _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), + _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, + _mm256_set1_pd(-0.0)))))); + // const __mm512d cc = _mm512_mul_pd(as, bi); + // return _mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc); #endif - } + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator * (const Vector,4> & a, const Vector,4> & b) { - return _mm256_mul_pd(a, b); - } + return _mm256_mul_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static Vector >,2> - operator * (const Vector >,2> & a, const Vector >,2> & b) { - const __m256d - as = _mm256_permute_pd(a, 0x5), - br = _mm256_permute_pd(b, 0x0), - bi = _mm256_permute_pd(b, 0xf); + KOKKOS_FORCEINLINE_FUNCTION + static Vector >,2> + operator * (const Vector >,2> & a, const Vector >,2> & b) { + const __m256d + as = _mm256_permute_pd(a, 0x5), + br = _mm256_permute_pd(b, 0x0), + bi = _mm256_permute_pd(b, 0xf); #if defined(__FMA__) - return _mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)); + return _mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)); #else - return _mm256_add_pd(_mm256_mul_pd(a, br), - _mm256_xor_pd(_mm256_mul_pd(as, bi), - _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))); + return _mm256_add_pd(_mm256_mul_pd(a, br), + _mm256_xor_pd(_mm256_mul_pd(as, bi), + _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))); #endif - } + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator * (const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x * b.double2().x; - r_val.y = a.double2().y * b.double2().y; - return r_val; - } + double2 r_val; + r_val.x = a.double2().x * b.double2().x; + r_val.y = a.double2().y * b.double2().y; + return r_val; + } #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator *= (Vector,l> &a, const Vector,l> &b) { - a = a * b; - return a; - } + a = a * b; + return a; + } - /// simd, real + /// simd, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator * (const Vector,l> &a, const T b) { - return a * Vector,l>(b); - } + return a * Vector,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator * (const T a, const Vector,l> &b) { - return Vector,l>(a) * b; - } + return Vector,l>(a) * b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator *= (Vector,l> &a, const T b) { - a = a * b; - return a; - } + a = a * b; + return a; + } - /// simd complex, real + /// simd complex, real #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator * (const Vector >,4> &a, const double b) { - return _mm512_mul_pd(a, _mm512_set1_pd(b)); - } + return _mm512_mul_pd(a, _mm512_set1_pd(b)); + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) operator * (const Vector >,2> & a, const double b) { - return _mm256_mul_pd(a, _mm256_set1_pd(b)); - } + return _mm256_mul_pd(a, _mm256_set1_pd(b)); + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator * (const Vector >,l> &a, const T b) { - return a * Vector >,l>(b); - } + return a * Vector >,l>(b); + } #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator * (const double a, const Vector >,4> &b) { - return _mm512_mul_pd(_mm512_set1_pd(a), b); - } + return _mm512_mul_pd(_mm512_set1_pd(a), b); + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) operator * (const double a, const Vector >,2> & b) { - return _mm256_mul_pd(_mm256_set1_pd(a), b); - } + return _mm256_mul_pd(_mm256_set1_pd(a), b); + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator * (const T a, const Vector >,l> &b) { - return Vector >,l>(a) * b; - } + return Vector >,l>(a) * b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator *= (Vector >,l> &a, const T b) { - a = a * b; - return a; - } + a = a * b; + return a; + } - /// simd complex, complex + /// simd complex, complex - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator * (const Vector >,l> &a, const Kokkos::complex b) { - return a * Vector >,l>(b); - } + return a * Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator * (const Kokkos::complex a, const Vector >,l> &b) { - return Vector >,l>(a) * b; - } + return Vector >,l>(a) * b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator *= (Vector >,l> &a, const Kokkos::complex b) { - a = a * b; - return a; - } + a = a * b; + return a; + } - /// --------------------------------------------------------------------------------------------------- + /// --------------------------------------------------------------------------------------------------- - /// simd, simd + /// simd, simd #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,8) operator / (const Vector,8> &a, const Vector,8> &b) { - return _mm512_div_pd(a, b); - } + return _mm512_div_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator / (const Vector >,4> &a, const Vector >,4> &b) { - const __m512d - as = _mm512_permute_pd(a, 0x55), - cb = _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(b), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, - _mm256_set1_pd(-0.0))))), - br = _mm512_permute_pd(cb, 0x00), - bi = _mm512_permute_pd(cb, 0xff); + const __m512d + as = _mm512_permute_pd(a, 0x55), + cb = _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(b), + _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, + _mm256_set1_pd(-0.0))))), + br = _mm512_permute_pd(cb, 0x00), + bi = _mm512_permute_pd(cb, 0xff); #if defined(__FMA__) - return _mm512_div_pd(_mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)), - _mm512_fmadd_pd (br, br, _mm512_mul_pd(bi, bi))); + return _mm512_div_pd(_mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)), + _mm512_fmadd_pd (br, br, _mm512_mul_pd(bi, bi))); #else - return _mm512_div_pd(_mm512_add_pd(_mm512_mul_pd(a, br), - _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, - _mm256_set1_pd(-0.0)))))), - _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); - // const __mm512d cc = _mm512_mul_pd(as, bi); - // return _mm512_div_pd(_mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc), - // _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); + return _mm512_div_pd(_mm512_add_pd(_mm512_mul_pd(a, br), + _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), + _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, + _mm256_set1_pd(-0.0)))))), + _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); + // const __mm512d cc = _mm512_mul_pd(as, bi); + // return _mm512_div_pd(_mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc), + // _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); #endif - } + } #endif #endif #if defined(__AVX__) || defined(__AVX2__) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator / (const Vector,4> & a, const Vector,4> & b) { - return _mm256_div_pd(a, b); - } + return _mm256_div_pd(a, b); + } #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,2) operator / (Vector >,2> const & a, Vector >,2> const & b) { - const __m256d - as = _mm256_permute_pd(a, 0x5), - cb = _mm256_xor_pd(b, _mm256_set_pd(-0.0, 0.0, -0.0, 0.0)), - br = _mm256_permute_pd(cb, 0x0), - bi = _mm256_permute_pd(cb, 0xf); + const __m256d + as = _mm256_permute_pd(a, 0x5), + cb = _mm256_xor_pd(b, _mm256_set_pd(-0.0, 0.0, -0.0, 0.0)), + br = _mm256_permute_pd(cb, 0x0), + bi = _mm256_permute_pd(cb, 0xf); #if defined(__FMA__) - return _mm256_div_pd(_mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)), - _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); + return _mm256_div_pd(_mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)), + _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); #else - return _mm256_div_pd(_mm256_add_pd(_mm256_mul_pd(a, br), - _mm256_xor_pd(_mm256_mul_pd(as, bi), - _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))), - _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); + return _mm256_div_pd(_mm256_add_pd(_mm256_mul_pd(a, br), + _mm256_xor_pd(_mm256_mul_pd(as, bi), + _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))), + _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); #endif - } + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator / (const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x / b.double2().x; - r_val.y = a.double2().y / b.double2().y; - return r_val; - } + double2 r_val; + r_val.x = a.double2().x / b.double2().x; + r_val.y = a.double2().y / b.double2().y; + return r_val; + } #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator /= (Vector,l> &a, const Vector,l> &b) { - a = a / b; - return a; - } + a = a / b; + return a; + } - /// simd, real + /// simd, real #if defined(__KOKKOSBATCHED_ENABLE_AVX__) #if defined(__AVX512F__) #if !defined(KOKKOS_COMPILER_GNU) - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,4) operator / (const Vector >,4> &a, const double b) { - return _mm512_div_pd(a, _mm512_set1_pd(b)); - } + return _mm512_div_pd(a, _mm512_set1_pd(b)); + } #endif #endif #endif - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator / (const Vector,l> &a, const T b) { - return a / Vector,l>(b); - } + return a / Vector,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(T,l) operator / (const T a, const Vector,l> &b) { - return Vector,l>(a) / b; - } + return Vector,l>(a) / b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(T,l) operator /= (Vector,l> &a, const T b) { - a = a / b; - return a; - } + a = a / b; + return a; + } - /// simd complex, real + /// simd complex, real - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator / (const Vector >,l> &a, const T b) { - return a / Vector >,l>(b); - } + return a / Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator / (const T a, const Vector >,l> &b) { - return Vector >,l>(a) / b; - } + return Vector >,l>(a) / b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator /= (Vector >,l> &a, const T b) { - a = a / b; - return a; - } + a = a / b; + return a; + } - /// simd complex, complex + /// simd complex, complex - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator / (const Vector >,l> &a, const Kokkos::complex b) { - return a / Vector >,l>(b); - } + return a / Vector >,l>(b); + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(Kokkos::complex,l) operator / (const Kokkos::complex a, const Vector >,l> &b) { - return Vector >,l>(a) / b; - } + return Vector >,l>(a) / b; + } - template - KOKKOS_FORCEINLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) + template + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE(Kokkos::complex,l) operator /= (Vector >,l> &a, const Kokkos::complex b) { - a = a / b; - return a; - } + a = a / b; + return a; + } #undef KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE #undef KOKKOSKERNELS_SIMD_ARITH_RETURN_REFERENCE_TYPE - } } + #endif diff --git a/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp b/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp index 1f871086d4..854d5dbc30 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Logical.hpp @@ -6,130 +6,129 @@ #include "Kokkos_Complex.hpp" namespace KokkosBatched { - namespace Experimental { #define KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) typename std::enable_if::value && std::is_integral< T1 >::value,const Vector,l> >::type - template - KOKKOS_INLINE_FUNCTION - static - typename std::enable_if::value,const Vector,l> >::type - operator!(const Vector,l> &a) { - Vector,l> r_val; + template + KOKKOS_INLINE_FUNCTION + static + typename std::enable_if::value,const Vector,l> >::type + operator!(const Vector,l> &a) { + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const Vector,l> &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const Vector,l> &a, const T1 &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const Vector,l> &a, const T1 &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator||(const T0 &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_LOGICAL_RETURN_BOOL_TYPE(T0,T1,l) operator&&(const T0 &a, const Vector,l> &b) { - Vector,l> r_val; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i::value,Vector,l> >::type + //#define KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE typename std::enable_if::value,Vector,l> >::type #define KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) Vector< SIMD< T >, l > #define KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) typename std::enable_if::value,Vector,l> >::type - /// simd + /// simd - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) sqrt(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) cbrt(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) log(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) log10(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T,l) exp(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const Vector,l> &a, const Vector,l> &b) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const T0 &a, const Vector,l> &b) { - return pow(Vector,l>(a), b); - } + return pow(Vector,l>(a), b); + } - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE(T0,l) pow(const Vector,l> &a, const T1 &b) { - return pow(a, Vector,l>(b)); - } + return pow(a, Vector,l>(b)); + } - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) sin(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) cos(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) tan(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) sinh(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) cosh(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) tanh(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) asin(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) acos(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan(const Vector,l> &a) { - typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const Vector,l> &a, const Vector,l> &b) { - //typedef Kokkos::Details::ArithTraits ats; - Vector,l> r_val; + //typedef Kokkos::Details::ArithTraits ats; + Vector,l> r_val; #if defined( KOKKOS_ENABLE_PRAGMA_IVDEP ) #pragma ivdep #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always #endif - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const T &a, const Vector,l> &b) { - return atan2(Vector,l>(a), b); - } + return atan2(Vector,l>(a), b); + } - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE(T,l) atan2(const Vector,l> &a, const T &b) { - return atan2(a, Vector,l>(b)); - } + return atan2(a, Vector,l>(b)); + } #undef KOKKOSKERNELS_SIMD_MATH_RETURN_TYPE #undef KOKKOSKERNELS_SIMD_MATH_RETURN_FLOAT_TYPE - } } + #endif diff --git a/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp b/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp index bebd29b627..03f5161162 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Misc.hpp @@ -6,204 +6,203 @@ #include "Kokkos_Complex.hpp" namespace KokkosBatched { - namespace Experimental { #define KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) Vector< SIMD< T >, l > #define KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) void - //typename std::enable_if::value && std::is_convertible< T2 , T0 >::value, void >::type - - // scalar, scalar - - template - KOKKOS_INLINE_FUNCTION - static - T - conditional_assign(const bool cond, - const T &if_true_val, - const T &if_false_val) { - return cond ? if_true_val : if_false_val; - } + //typename std::enable_if::value && std::is_convertible< T2 , T0 >::value, void >::type + + // scalar, scalar + + template + KOKKOS_INLINE_FUNCTION + static + T + conditional_assign(const bool cond, + const T &if_true_val, + const T &if_false_val) { + return cond ? if_true_val : if_false_val; + } - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ T0 &r_val, const bool cond, const T1 &if_true_val, const T2 &if_false_val) { - r_val = cond ? if_true_val : if_false_val; - } + r_val = cond ? if_true_val : if_false_val; + } - // vector, scalar + // vector, scalar - template - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, const Vector,l> &if_true_val, const T &if_false_val) { - Vector,l> r_val; - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) + Vector,l> r_val; + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, const Vector,l> &cond, const Vector,l> &if_true_val, const T2 &if_false_val) { - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, const T &if_true_val, const Vector,l> &if_false_val) { - Vector,l> r_val; - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) + Vector,l> r_val; + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, const Vector,l> &cond, const T1 &if_true_val, const Vector,l> &if_false_val){ - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) + template + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE(T,l) conditional_assign(const Vector,l> &cond, const Vector,l> &if_true_val, const Vector,l> &if_false_val) { - Vector,l> r_val; - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) + Vector,l> r_val; + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE(T0,T1,T2,l) conditional_assign(/* */ Vector,l> &r_val, const Vector,l> &cond, const Vector,l> &if_true_val, const Vector,l> &if_false_val){ - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - T - reduce(const Vector,l> &val, const BinaryOp &func) { - T r_val = val[0]; - for (int i=1;i - KOKKOS_INLINE_FUNCTION - static - T - reduce(const Vector,l> &val, const BinaryOp &func, const T init) { - T r_val = init; - for (int i=0;i - KOKKOS_INLINE_FUNCTION - static - bool - is_all_true(const Vector,l> &cond) { - return reduce(cond, [](const bool left, const bool right) -> bool { - return (left && right); - }); - } - - template - KOKKOS_INLINE_FUNCTION - static - bool - is_any_true(const Vector,l> &cond) { - return reduce(cond, [](const bool left, const bool right) -> bool { - return left || right; - }); - } - - template - KOKKOS_INLINE_FUNCTION - static - T - min(const Vector,l> &val) { - return reduce(val, [](const T left, const T right) -> T { - const auto tmp = left < right; - return tmp*left + !tmp*right; - }); - } - - template - KOKKOS_INLINE_FUNCTION - static - T - max(const Vector,l> &val) { - return reduce(val, [](const T left, const T right) -> T { - const auto tmp = left > right; - return tmp*left + !tmp*right; - }); - } - - template - KOKKOS_INLINE_FUNCTION - static - T - sum(const Vector,l> &val) { - return reduce(val, [](const T left, const T right) -> T { - return left + right; - }, T(0)); - } - - template - KOKKOS_INLINE_FUNCTION - static - T - prod(const Vector,l> &val) { - return reduce(val, [](const T left, const T right) -> T { - return left * right; - }, T(1)); - } + template + KOKKOS_INLINE_FUNCTION + static + T + reduce(const Vector,l> &val, const BinaryOp &func) { + T r_val = val[0]; + for (int i=1;i + KOKKOS_INLINE_FUNCTION + static + T + reduce(const Vector,l> &val, const BinaryOp &func, const T init) { + T r_val = init; + for (int i=0;i + KOKKOS_INLINE_FUNCTION + static + bool + is_all_true(const Vector,l> &cond) { + return reduce(cond, [](const bool left, const bool right) -> bool { + return (left && right); + }); + } + + template + KOKKOS_INLINE_FUNCTION + static + bool + is_any_true(const Vector,l> &cond) { + return reduce(cond, [](const bool left, const bool right) -> bool { + return left || right; + }); + } + + template + KOKKOS_INLINE_FUNCTION + static + T + min(const Vector,l> &val) { + return reduce(val, [](const T left, const T right) -> T { + const auto tmp = left < right; + return tmp*left + !tmp*right; + }); + } + + template + KOKKOS_INLINE_FUNCTION + static + T + max(const Vector,l> &val) { + return reduce(val, [](const T left, const T right) -> T { + const auto tmp = left > right; + return tmp*left + !tmp*right; + }); + } + + template + KOKKOS_INLINE_FUNCTION + static + T + sum(const Vector,l> &val) { + return reduce(val, [](const T left, const T right) -> T { + return left + right; + }, T(0)); + } + + template + KOKKOS_INLINE_FUNCTION + static + T + prod(const Vector,l> &val) { + return reduce(val, [](const T left, const T right) -> T { + return left * right; + }, T(1)); + } #undef KOKKOSKERNELS_SIMD_MISC_RETURN_TYPE #undef KOKKOSKERNELS_SIMD_MISC_CONVERTIBLE_RETURN_VOID_TYPE - } } + #endif diff --git a/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp b/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp index f5796dc115..6ef8942f16 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Relation.hpp @@ -6,68 +6,66 @@ #include "Kokkos_Complex.hpp" namespace KokkosBatched { - namespace Experimental { - // vector, vector + // vector, vector #undef KOKKOSBATCHED_RELATION_OPERATOR #define KOKKOSBATCHED_RELATION_OPERATOR(op) \ - template \ - KOKKOS_INLINE_FUNCTION \ - const Vector,l> operator op (const Vector,l> &a, const Vector,l> &b) { \ - Vector,l> r_val; \ - for (int i=0;i \ + KOKKOS_INLINE_FUNCTION \ + const Vector,l> operator op (const Vector,l> &a, const Vector,l> &b) { \ + Vector,l> r_val; \ + for (int i=0;i) - KOKKOSBATCHED_RELATION_OPERATOR(<=) - KOKKOSBATCHED_RELATION_OPERATOR(>=) - KOKKOSBATCHED_RELATION_OPERATOR(==) - KOKKOSBATCHED_RELATION_OPERATOR(!=) + KOKKOSBATCHED_RELATION_OPERATOR(<) + KOKKOSBATCHED_RELATION_OPERATOR(>) + KOKKOSBATCHED_RELATION_OPERATOR(<=) + KOKKOSBATCHED_RELATION_OPERATOR(>=) + KOKKOSBATCHED_RELATION_OPERATOR(==) + KOKKOSBATCHED_RELATION_OPERATOR(!=) - // vector, scalar + // vector, scalar #undef KOKKOSBATCHED_RELATION_OPERATOR #define KOKKOSBATCHED_RELATION_OPERATOR(op) \ - template \ - KOKKOS_INLINE_FUNCTION \ - const Vector,l> operator op (const Vector,l> &a, const T2 &b) { \ - Vector,l> r_val; \ - for (int i=0;i \ + KOKKOS_INLINE_FUNCTION \ + const Vector,l> operator op (const Vector,l> &a, const T2 &b) { \ + Vector,l> r_val; \ + for (int i=0;i) - KOKKOSBATCHED_RELATION_OPERATOR(<=) - KOKKOSBATCHED_RELATION_OPERATOR(>=) - KOKKOSBATCHED_RELATION_OPERATOR(==) - KOKKOSBATCHED_RELATION_OPERATOR(!=) + KOKKOSBATCHED_RELATION_OPERATOR(<) + KOKKOSBATCHED_RELATION_OPERATOR(>) + KOKKOSBATCHED_RELATION_OPERATOR(<=) + KOKKOSBATCHED_RELATION_OPERATOR(>=) + KOKKOSBATCHED_RELATION_OPERATOR(==) + KOKKOSBATCHED_RELATION_OPERATOR(!=) - // scalar, vector + // scalar, vector #undef KOKKOSBATCHED_RELATION_OPERATOR #define KOKKOSBATCHED_RELATION_OPERATOR(op) \ - template \ - KOKKOS_INLINE_FUNCTION \ - const Vector,l> operator op (const T1 &a, const Vector,l> &b) { \ - Vector,l> r_val; \ - for (int i=0;i \ + KOKKOS_INLINE_FUNCTION \ + const Vector,l> operator op (const T1 &a, const Vector,l> &b) { \ + Vector,l> r_val; \ + for (int i=0;i) - KOKKOSBATCHED_RELATION_OPERATOR(<=) - KOKKOSBATCHED_RELATION_OPERATOR(>=) - KOKKOSBATCHED_RELATION_OPERATOR(==) - KOKKOSBATCHED_RELATION_OPERATOR(!=) + KOKKOSBATCHED_RELATION_OPERATOR(<) + KOKKOSBATCHED_RELATION_OPERATOR(>) + KOKKOSBATCHED_RELATION_OPERATOR(<=) + KOKKOSBATCHED_RELATION_OPERATOR(>=) + KOKKOSBATCHED_RELATION_OPERATOR(==) + KOKKOSBATCHED_RELATION_OPERATOR(!=) #undef KOKKOSBATCHED_RELATION_OPERATOR - } } #endif diff --git a/src/batched/KokkosBatched_Vector_SIMD_View.hpp b/src/batched/KokkosBatched_Vector_SIMD_View.hpp index f44388a5e9..6fca08d860 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_View.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_View.hpp @@ -6,210 +6,209 @@ #pragma GCC diagnostic ignored "-Wswitch" namespace KokkosBatched { - namespace Experimental { - template - struct PackDim { - enum : int { value = dim }; - }; + template + struct PackDim { + enum : int { value = dim }; + }; - // temporary solution until kokkos support SIMD layout or I do support it - template - struct SimdViewAccess { - private: - ViewType _a; + // temporary solution until kokkos support SIMD layout or I do support it + template + struct SimdViewAccess { + private: + ViewType _a; - public: - typedef typename ViewType::reference_type reference_simd_type ; - typedef typename ViewType::pointer_type pointer_simd_type ; - typedef typename ViewType::value_type value_simd_type; - - typedef typename value_simd_type::value_type value_type; - typedef value_type& reference_type; - typedef value_type* pointer_type; + public: + typedef typename ViewType::reference_type reference_simd_type ; + typedef typename ViewType::pointer_type pointer_simd_type ; + typedef typename ViewType::value_type value_simd_type; + + typedef typename value_simd_type::value_type value_type; + typedef value_type& reference_type; + typedef value_type* pointer_type; - enum : int { rank = ViewType::rank }; - enum : int { pack_dim = PackDim::value }; - enum : int { vector_length = value_simd_type::vector_length }; + enum : int { rank = ViewType::rank }; + enum : int { pack_dim = PackDim::value }; + enum : int { vector_length = value_simd_type::vector_length }; - SimdViewAccess() : _a() {} - SimdViewAccess(const ViewType &a) : _a(a) {} - - SimdViewAccess & operator=(const ViewType &b) { - _a = b; - return *this; - } - SimdViewAccess & operator=(const SimdViewAccess &b) { - if (this != &b) { - _a = b._a; - } - return *this; + SimdViewAccess() : _a() {} + SimdViewAccess(const ViewType &a) : _a(a) {} + + SimdViewAccess & operator=(const ViewType &b) { + _a = b; + return *this; + } + SimdViewAccess & operator=(const SimdViewAccess &b) { + if (this != &b) { + _a = b._a; } - - template< typename iType > - KOKKOS_INLINE_FUNCTION constexpr - typename std::enable_if< std::is_integral::value , size_t >::type - extent( const iType & r ) const - { return _a.extent(r)*(r == PackDim::value ? vector_length : 1); } + return *this; + } + + template< typename iType > + KOKKOS_INLINE_FUNCTION constexpr + typename std::enable_if< std::is_integral::value , size_t >::type + extent( const iType & r ) const + { return _a.extent(r)*(r == PackDim::value ? vector_length : 1); } - template< typename iType > - KOKKOS_INLINE_FUNCTION constexpr - typename std::enable_if< std::is_integral::value , int >::type - extent_int( const iType & r ) const - { return static_cast(_a.extent(r)*(r == PackDim::value ? vector_length : 1)); } + template< typename iType > + KOKKOS_INLINE_FUNCTION constexpr + typename std::enable_if< std::is_integral::value , int >::type + extent_int( const iType & r ) const + { return static_cast(_a.extent(r)*(r == PackDim::value ? vector_length : 1)); } #ifdef KOKKOS_ENABLE_DEPRECATED_CODE - template< typename iType > - KOKKOS_INLINE_FUNCTION constexpr - typename std::enable_if< std::is_integral::value , size_t >::type - dimension( const iType & r ) const { return extent( r ); } + template< typename iType > + KOKKOS_INLINE_FUNCTION constexpr + typename std::enable_if< std::is_integral::value , size_t >::type + dimension( const iType & r ) const { return extent( r ); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return _a.extent(0)*(0 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return _a.extent(1)*(1 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return _a.extent(2)*(2 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return _a.extent(3)*(3 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return _a.extent(4)*(4 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return _a.extent(5)*(5 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return _a.extent(6)*(6 == PackDim::value ? vector_length : 1); } - KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return _a.extent(7)*(7 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const { return _a.extent(0)*(0 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const { return _a.extent(1)*(1 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const { return _a.extent(2)*(2 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const { return _a.extent(3)*(3 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const { return _a.extent(4)*(4 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const { return _a.extent(5)*(5 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const { return _a.extent(6)*(6 == PackDim::value ? vector_length : 1); } + KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const { return _a.extent(7)*(7 == PackDim::value ? vector_length : 1); } #endif - KOKKOS_INLINE_FUNCTION constexpr size_t size() const { - return (_a.size() * vector_length); - } + KOKKOS_INLINE_FUNCTION constexpr size_t size() const { + return (_a.size() * vector_length); + } - KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return _a.span()*vector_length; } - KOKKOS_INLINE_FUNCTION constexpr bool span_span_is_contiguous() const { return _a.span_span_is_contiguous(); } - KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return _a.data(); } + KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return _a.span()*vector_length; } + KOKKOS_INLINE_FUNCTION constexpr bool span_span_is_contiguous() const { return _a.span_span_is_contiguous(); } + KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return _a.data(); } - /// rank 0 - /// this does not make sense as this is flat view to simd view + /// rank 0 + /// this does not make sense as this is flat view to simd view - /// rank 1 - template< typename I0 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 1 == ViewType::rank, reference_type >::type + /// rank 1 + template< typename I0 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 1 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , Args ... args ) const { - return _a(i0/vector_length)[i0%vector_length]; - } + return _a(i0/vector_length)[i0%vector_length]; + } - /// rank 2 - template< typename I0 , typename I1 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 2 == ViewType::rank, reference_type >::type + /// rank 2 + template< typename I0 , typename I1 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 2 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1)[i0%vector_length]; - case 1: break; - default:break; - } - return _a(i0,i1/vector_length)[i1%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1)[i0%vector_length]; + case 1: break; + default:break; } + return _a(i0,i1/vector_length)[i1%vector_length]; + } - /// rank 3 - template< typename I0 , typename I1 , typename I2 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 3 == ViewType::rank, reference_type >::type + /// rank 3 + template< typename I0 , typename I1 , typename I2 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 3 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2)[i1%vector_length]; - case 2: break; - default:break; - } - return _a(i0,i1,i2/vector_length)[i2%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2)[i1%vector_length]; + case 2: break; + default:break; } + return _a(i0,i1,i2/vector_length)[i2%vector_length]; + } - /// rank 4 - template< typename I0 , typename I1 , typename I2 , typename I3 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 4 == ViewType::rank, reference_type >::type + /// rank 4 + template< typename I0 , typename I1 , typename I2 , typename I3 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 4 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2,i3)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2,i3)[i1%vector_length]; - case 2: return _a(i0,i1,i2/vector_length,i3)[i2%vector_length]; - case 3: break; - default:break; - } - return _a(i0,i1,i2,i3/vector_length)[i3%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2,i3)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2,i3)[i1%vector_length]; + case 2: return _a(i0,i1,i2/vector_length,i3)[i2%vector_length]; + case 3: break; + default:break; } + return _a(i0,i1,i2,i3/vector_length)[i3%vector_length]; + } - /// rank 5 - template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 5 == ViewType::rank, reference_type >::type + /// rank 5 + template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 5 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 , const I4 & i4 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2,i3,i4)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2,i3,i4)[i1%vector_length]; - case 2: return _a(i0,i1,i2/vector_length,i3,i4)[i2%vector_length]; - case 3: return _a(i0,i1,i2,i3/vector_length,i4)[i3%vector_length]; - case 4: break; - default:break; - } - return _a(i0,i1,i2,i3,i4/vector_length)[i4%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2,i3,i4)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2,i3,i4)[i1%vector_length]; + case 2: return _a(i0,i1,i2/vector_length,i3,i4)[i2%vector_length]; + case 3: return _a(i0,i1,i2,i3/vector_length,i4)[i3%vector_length]; + case 4: break; + default:break; } + return _a(i0,i1,i2,i3,i4/vector_length)[i4%vector_length]; + } - /// rank 6 - template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 6 == ViewType::rank, reference_type >::type + /// rank 6 + template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 6 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 , const I4 & i4 , const I5 & i5 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5)[i1%vector_length]; - case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5)[i2%vector_length]; - case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5)[i3%vector_length]; - case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5)[i4%vector_length]; - case 5: break; - default:break; - } - return _a(i0,i1,i2,i3,i4,i5/vector_length)[i5%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5)[i1%vector_length]; + case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5)[i2%vector_length]; + case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5)[i3%vector_length]; + case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5)[i4%vector_length]; + case 5: break; + default:break; } + return _a(i0,i1,i2,i3,i4,i5/vector_length)[i5%vector_length]; + } - /// rank 7 - template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 7 == ViewType::rank, reference_type >::type + /// rank 7 + template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 7 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 , const I4 & i4 , const I5 & i5 , const I6 & i6 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5,i6)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5,i6)[i1%vector_length]; - case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5,i6)[i2%vector_length]; - case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5,i6)[i3%vector_length]; - case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5,i6)[i4%vector_length]; - case 5: return _a(i0,i1,i2,i3,i4,i5/vector_length,i6)[i5%vector_length]; - case 6: break; - default:break; - } - return _a(i0,i1,i2,i3,i4,i5,i6/vector_length)[i6%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5,i6)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5,i6)[i1%vector_length]; + case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5,i6)[i2%vector_length]; + case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5,i6)[i3%vector_length]; + case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5,i6)[i4%vector_length]; + case 5: return _a(i0,i1,i2,i3,i4,i5/vector_length,i6)[i5%vector_length]; + case 6: break; + default:break; } + return _a(i0,i1,i2,i3,i4,i5,i6/vector_length)[i6%vector_length]; + } - /// rank 8 - template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 , typename I7 , class ... Args > - KOKKOS_FORCEINLINE_FUNCTION - typename std::enable_if::value && 8 == ViewType::rank, reference_type >::type + /// rank 8 + template< typename I0 , typename I1 , typename I2 , typename I3 , typename I4 , typename I5 , typename I6 , typename I7 , class ... Args > + KOKKOS_FORCEINLINE_FUNCTION + typename std::enable_if::value && 8 == ViewType::rank, reference_type >::type operator()( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 , Args ... args ) const { - switch (PackDim::value) { - case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5,i6,i7)[i0%vector_length]; - case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5,i6,i7)[i1%vector_length]; - case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5,i6,i7)[i2%vector_length]; - case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5,i6,i7)[i3%vector_length]; - case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5,i6,i7)[i4%vector_length]; - case 5: return _a(i0,i1,i2,i3,i4,i5/vector_length,i6,i7)[i5%vector_length]; - case 6: return _a(i0,i1,i2,i3,i4,i5,i6/vector_length,i7)[i6%vector_length]; - case 7: break; - default:break; - } - return _a(i0,i1,i2,i3,i4,i5,i6,i7/vector_length)[i7%vector_length]; + switch (PackDim::value) { + case 0: return _a(i0/vector_length,i1,i2,i3,i4,i5,i6,i7)[i0%vector_length]; + case 1: return _a(i0,i1/vector_length,i2,i3,i4,i5,i6,i7)[i1%vector_length]; + case 2: return _a(i0,i1,i2/vector_length,i3,i4,i5,i6,i7)[i2%vector_length]; + case 3: return _a(i0,i1,i2,i3/vector_length,i4,i5,i6,i7)[i3%vector_length]; + case 4: return _a(i0,i1,i2,i3,i4/vector_length,i5,i6,i7)[i4%vector_length]; + case 5: return _a(i0,i1,i2,i3,i4,i5/vector_length,i6,i7)[i5%vector_length]; + case 6: return _a(i0,i1,i2,i3,i4,i5,i6/vector_length,i7)[i6%vector_length]; + case 7: break; + default:break; } - }; - } + return _a(i0,i1,i2,i3,i4,i5,i6,i7/vector_length)[i7%vector_length]; + } + }; } + #pragma GCC diagnostic pop #endif diff --git a/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp index 5393580f63..c4bfa908ae 100644 --- a/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp +++ b/src/batched/KokkosBatched_WilkinsonShift_Serial_Internal.hpp @@ -6,57 +6,54 @@ #include "KokkosBatched_Util.hpp" - namespace KokkosBatched { - namespace Experimental { - /// - /// Serial Internal Impl - /// ==================== - /// - /// this impl follows the flame interface of householder transformation - /// - struct SerialWilkinsonShiftInternal { - template - KOKKOS_INLINE_FUNCTION - static int - invoke(const ValueType a, const ValueType b, - const ValueType c, const ValueType d, - /* */ Kokkos::complex * lambda1, - /* */ Kokkos::complex * lambda2, - /* */ bool * is_complex) { - /// compute eigenvalues of 2x2 system [a b; - /// c d] - /// when the system has a real complex values, - /// lambda1 and lambda2 are real eigenvalues - /// if the system has a complex eigenvalue pair, - /// then lambda1 and lambda2 are redefined as follows - /// lambda1 := lambda1 + lambda2 - /// lambda2 := lambda1 * lambda2 - typedef ValueType value_type; + /// + /// Serial Internal Impl + /// ==================== + /// + /// this impl follows the flame interface of householder transformation + /// + struct SerialWilkinsonShiftInternal { + template + KOKKOS_INLINE_FUNCTION + static int + invoke(const ValueType a, const ValueType b, + const ValueType c, const ValueType d, + /* */ Kokkos::complex * lambda1, + /* */ Kokkos::complex * lambda2, + /* */ bool * is_complex) { + /// compute eigenvalues of 2x2 system [a b; + /// c d] + /// when the system has a real complex values, + /// lambda1 and lambda2 are real eigenvalues + /// if the system has a complex eigenvalue pair, + /// then lambda1 and lambda2 are redefined as follows + /// lambda1 := lambda1 + lambda2 + /// lambda2 := lambda1 * lambda2 + typedef ValueType value_type; - const value_type half(0.5); - const value_type p = (a+d)*half; - const value_type q = (b*c-a*d); - const value_type v = p*p+q; - - if (v < 0) { - // complex - const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(-v); - *lambda1 = Kokkos::complex(p, sqrt_v); - *lambda2 = Kokkos::complex(p,-sqrt_v); - *is_complex = true; - } else { - // real - const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(v); - *lambda1 = Kokkos::complex(p+sqrt_v); - *lambda2 = Kokkos::complex(p-sqrt_v); - *is_complex = false; - } - return 0; + const value_type half(0.5); + const value_type p = (a+d)*half; + const value_type q = (b*c-a*d); + const value_type v = p*p+q; + + if (v < 0) { + // complex + const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(-v); + *lambda1 = Kokkos::complex(p, sqrt_v); + *lambda2 = Kokkos::complex(p,-sqrt_v); + *is_complex = true; + } else { + // real + const value_type sqrt_v = Kokkos::Details::ArithTraits::sqrt(v); + *lambda1 = Kokkos::complex(p+sqrt_v); + *lambda2 = Kokkos::complex(p-sqrt_v); + *is_complex = false; } - }; + return 0; + } + }; - }// end namespace Experimental } // end namespace KokkosBatched From 237c52e77e21bb1c965e1a7a1493506af27dd50c Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 8 Apr 2019 11:58:30 -0600 Subject: [PATCH 159/190] KokkosBatched - remove experimental from test --- .../KokkosBatched_Test_BlockCrs_Cuda.cpp | 20 +- .../KokkosBatched_Test_BlockCrs_Host.cpp | 22 +- .../KokkosBatched_Test_BlockTridiagDirect.cpp | 4 +- .../KokkosBatched_Test_BlockTridiagJacobi.cpp | 4 +- .../batched/KokkosBatched_Test_Gemm_Cuda.cpp | 960 +++++++------- .../batched/KokkosBatched_Test_Gemm_Host.hpp | 872 +++++++------ .../KokkosBatched_Test_Gemm_Host_Complex.cpp | 2 +- .../KokkosBatched_Test_Gemm_Host_Real.cpp | 2 +- .../batched/KokkosBatched_Test_Gemv_Host.hpp | 412 +++--- .../KokkosBatched_Test_Gemv_Host_Real.cpp | 2 +- .../batched/KokkosBatched_Test_LU_Cuda.cpp | 781 ++++++----- .../batched/KokkosBatched_Test_LU_Host.hpp | 488 ++++--- .../KokkosBatched_Test_LU_Host_Real.cpp | 2 +- .../batched/KokkosBatched_Test_Trsm_Cuda.cpp | 1160 ++++++++--------- .../batched/KokkosBatched_Test_Trsm_Host.hpp | 1060 ++++++++------- .../KokkosBatched_Test_Trsm_Host_Real.cpp | 2 +- test_common/KokkosBatched_Test_BlockCrs.hpp | 1 - .../Test_Batched_SerialEigendecomposition.hpp | 2 +- unit_test/batched/Test_Batched_SerialGemm.hpp | 34 +- unit_test/batched/Test_Batched_SerialGemv.hpp | 2 +- .../batched/Test_Batched_SerialInverseLU.hpp | 2 +- unit_test/batched/Test_Batched_SerialLU.hpp | 2 +- .../batched/Test_Batched_SerialMatUtil.hpp | 2 +- .../batched/Test_Batched_SerialSolveLU.hpp | 2 +- unit_test/batched/Test_Batched_SerialTrsm.hpp | 2 +- unit_test/batched/Test_Batched_SerialTrsv.hpp | 2 +- unit_test/batched/Test_Batched_TeamGemm.hpp | 34 +- unit_test/batched/Test_Batched_TeamGemv.hpp | 2 +- .../batched/Test_Batched_TeamInverseLU.hpp | 2 +- unit_test/batched/Test_Batched_TeamLU.hpp | 2 +- .../batched/Test_Batched_TeamMatUtil.hpp | 2 +- .../batched/Test_Batched_TeamSolveLU.hpp | 2 +- unit_test/batched/Test_Batched_TeamTrsm.hpp | 2 +- unit_test/batched/Test_Batched_TeamTrsv.hpp | 2 +- .../batched/Test_Batched_VectorArithmatic.hpp | 2 +- .../batched/Test_Batched_VectorLogical.hpp | 2 +- unit_test/batched/Test_Batched_VectorMath.hpp | 2 +- unit_test/batched/Test_Batched_VectorMisc.hpp | 2 +- .../batched/Test_Batched_VectorRelation.hpp | 2 +- unit_test/batched/Test_Batched_VectorView.hpp | 2 +- 40 files changed, 2945 insertions(+), 2959 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_BlockCrs_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_BlockCrs_Cuda.cpp index b2a86dc2ea..c374f47308 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockCrs_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockCrs_Cuda.cpp @@ -31,20 +31,20 @@ //#define KOKKOSBATCHED_USE_BLOCKED_ALGO 1 #if defined (KOKKOSBATCHED_USE_UNBLOCKED_ALGO) -typedef KokkosBatched::Experimental::Algo::LU::Unblocked AlgoLU; -typedef KokkosBatched::Experimental::Algo::Trsm::Unblocked AlgoTrsm; -typedef KokkosBatched::Experimental::Algo::Gemm::Unblocked AlgoGemm; +typedef KokkosBatched::Algo::LU::Unblocked AlgoLU; +typedef KokkosBatched::Algo::Trsm::Unblocked AlgoTrsm; +typedef KokkosBatched::Algo::Gemm::Unblocked AlgoGemm; -typedef KokkosBatched::Experimental::Algo::Trsv::Unblocked AlgoTrsv; -typedef KokkosBatched::Experimental::Algo::Gemv::Unblocked AlgoGemv; +typedef KokkosBatched::Algo::Trsv::Unblocked AlgoTrsv; +typedef KokkosBatched::Algo::Gemv::Unblocked AlgoGemv; #endif #if defined (KOKKOSBATCHED_USE_BLOCKED_ALGO) -typedef KokkosBatched::Experimental::Algo::LU::Blocked AlgoLU; -typedef KokkosBatched::Experimental::Algo::Trsm::Blocked AlgoTrsm; -typedef KokkosBatched::Experimental::Algo::Gemm::Blocked AlgoGemm; +typedef KokkosBatched::Algo::LU::Blocked AlgoLU; +typedef KokkosBatched::Algo::Trsm::Blocked AlgoTrsm; +typedef KokkosBatched::Algo::Gemm::Blocked AlgoGemm; -typedef KokkosBatched::Experimental::Algo::Trsv::Blocked AlgoTrsv; -typedef KokkosBatched::Experimental::Algo::Gemv::Blocked AlgoGemv; +typedef KokkosBatched::Algo::Trsv::Blocked AlgoTrsv; +typedef KokkosBatched::Algo::Gemv::Blocked AlgoGemv; #endif #include "KokkosBatched_Test_BlockCrs.hpp" diff --git a/perf_test/batched/KokkosBatched_Test_BlockCrs_Host.cpp b/perf_test/batched/KokkosBatched_Test_BlockCrs_Host.cpp index 0b1aca18e7..d0a30a147e 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockCrs_Host.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockCrs_Host.cpp @@ -28,20 +28,20 @@ #define KOKKOSBATCHED_USE_BLOCKED_ALGO 1 #if defined (KOKKOSBATCHED_USE_UNBLOCKED_ALGO) -typedef KokkosBatched::Experimental::Algo::LU::Unblocked AlgoLU; -typedef KokkosBatched::Experimental::Algo::Trsm::Unblocked AlgoTrsm; -typedef KokkosBatched::Experimental::Algo::Gemm::Unblocked AlgoGemm; +typedef KokkosBatched::Algo::LU::Unblocked AlgoLU; +typedef KokkosBatched::Algo::Trsm::Unblocked AlgoTrsm; +typedef KokkosBatched::Algo::Gemm::Unblocked AlgoGemm; -typedef KokkosBatched::Experimental::Algo::Trsv::Unblocked AlgoTrsv; -typedef KokkosBatched::Experimental::Algo::Gemv::Unblocked AlgoGemv; +typedef KokkosBatched::Algo::Trsv::Unblocked AlgoTrsv; +typedef KokkosBatched::Algo::Gemv::Unblocked AlgoGemv; #endif #if defined (KOKKOSBATCHED_USE_BLOCKED_ALGO) -typedef KokkosBatched::Experimental::Algo::LU::Blocked AlgoLU; -typedef KokkosBatched::Experimental::Algo::Trsm::Blocked AlgoTrsm; -typedef KokkosBatched::Experimental::Algo::Gemm::Blocked AlgoGemm; +typedef KokkosBatched::Algo::LU::Blocked AlgoLU; +typedef KokkosBatched::Algo::Trsm::Blocked AlgoTrsm; +typedef KokkosBatched::Algo::Gemm::Blocked AlgoGemm; -typedef KokkosBatched::Experimental::Algo::Trsv::Blocked AlgoTrsv; -typedef KokkosBatched::Experimental::Algo::Gemv::Blocked AlgoGemv; +typedef KokkosBatched::Algo::Trsv::Blocked AlgoTrsv; +typedef KokkosBatched::Algo::Gemv::Blocked AlgoGemv; #endif #include "KokkosBatched_Test_BlockCrs.hpp" @@ -61,7 +61,7 @@ int main (int argc, char *argv[]) { RangeTagOper = 0 }; // vector type - typedef Experimental::Vector,VectorLength> VectorType; + typedef Vector,VectorLength> VectorType; // Unit tests bool profile = false; diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp index 8a19f5c995..a4522fc526 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagDirect.cpp @@ -56,7 +56,7 @@ typedef double value_type; /// /// simd typedefs /// -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; static constexpr int vector_length = DefaultVectorLength::value; #if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) @@ -486,7 +486,7 @@ int main(int argc, char* argv[]) { /// compute residual /// if (1) { - typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + typedef KokkosBatched::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; using member_type = typename policy_type::member_type; policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); diff --git a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp index 349bd7f171..928232a7e5 100644 --- a/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp +++ b/perf_test/batched/KokkosBatched_Test_BlockTridiagJacobi.cpp @@ -57,7 +57,7 @@ typedef double value_type; /// /// simd typedefs /// -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; static constexpr int vector_length = DefaultVectorLength::value; #if defined(KOKKOSBATCHED_USE_128BIT_MEMORY_INST) @@ -419,7 +419,7 @@ int main(int argc, char* argv[]) { /// compute residual /// if (1) { - typedef KokkosBatched::Experimental::Algo::Level2::Unblocked algo_type; + typedef KokkosBatched::Algo::Level2::Unblocked algo_type; using policy_type = Kokkos::TeamPolicy; policy_type policy(Acopy.extent(0), Kokkos::AUTO(), Acopy.extent(5)); Kokkos::parallel_for diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp index 3477120a2e..bfb6d3d0f4 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp @@ -24,407 +24,482 @@ #include "KokkosBatched_Gemm_Team_Impl.hpp" namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #undef FLOP_MUL #undef FLOP_ADD #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; - double FlopCount(int mm, int nn, int kk) { - double m = (double)mm; double n = (double)nn; double k = (double)kk; - return (FLOP_MUL*(m*n*k) + - FLOP_ADD*(m*n*k)); - } + double FlopCount(int mm, int nn, int kk) { + double m = (double)mm; double n = (double)nn; double k = (double)kk; + return (FLOP_MUL*(m*n*k) + + FLOP_ADD*(m*n*k)); + } - struct RangeTag {}; - struct TeamTagV1 {}; - struct TeamTagV2 {}; - struct TeamTagV3 {}; - struct TeamTagHandmade {}; + struct RangeTag {}; + struct TeamTagV1 {}; + struct TeamTagV2 {}; + struct TeamTagV3 {}; + struct TeamTagHandmade {}; - template - struct Functor { - ConstUnmanagedViewType _a, _b; - UnmanagedViewType _c; + template + struct Functor { + ConstUnmanagedViewType _a, _b; + UnmanagedViewType _c; - KOKKOS_INLINE_FUNCTION - Functor() = default; + KOKKOS_INLINE_FUNCTION + Functor() = default; - KOKKOS_INLINE_FUNCTION - Functor(const ViewType &a, - const ViewType &b, - const ViewType &c) - : _a(a), _b(b), _c(c) {} + KOKKOS_INLINE_FUNCTION + Functor(const ViewType &a, + const ViewType &b, + const ViewType &c) + : _a(a), _b(b), _c(c) {} - KOKKOS_INLINE_FUNCTION - void operator()(const RangeTag &, const int k) const { - auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - auto cc = Kokkos::subview(_c, k, Kokkos::ALL(), Kokkos::ALL()); + KOKKOS_INLINE_FUNCTION + void operator()(const RangeTag &, const int k) const { + auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); + auto cc = Kokkos::subview(_c, k, Kokkos::ALL(), Kokkos::ALL()); - SerialGemm:: - invoke(1.0, aa, bb, 1.0, cc); - } + SerialGemm:: + invoke(1.0, aa, bb, 1.0, cc); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV1 &, const MemberType &member) const { - const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + - member.team_rank()*VectorLength); - Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_c.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV1 &, const MemberType &member) const { + const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + + member.team_rank()*VectorLength); + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_c.extent(0))) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); + auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); - SerialGemm:: - invoke(1.0, aa, bb, 1.0, cc); - } - }); - } - - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV2 &, const MemberType &member) const { - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_c.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); + SerialGemm:: + invoke(1.0, aa, bb, 1.0, cc); + } + }); + } + + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV2 &, const MemberType &member) const { + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_c.extent(0))) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); + auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); - TeamGemm:: - invoke(member, 1.0, aa, bb, 1.0, cc); - } - }); - } + TeamGemm:: + invoke(member, 1.0, aa, bb, 1.0, cc); + } + }); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV3 &, const MemberType &member) const { - const int lvl = 0; - ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); - ScratchViewType sb(member.team_scratch(lvl), VectorLength, _b.extent(1), _b.extent(2)); - - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_c.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV3 &, const MemberType &member) const { + const int lvl = 0; + ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); + ScratchViewType sb(member.team_scratch(lvl), VectorLength, _b.extent(1), _b.extent(2)); + + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_c.extent(0))) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); + auto cc = Kokkos::subview(_c, kk, Kokkos::ALL(), Kokkos::ALL()); - auto saa = Kokkos::subview(sa, k, Kokkos::ALL(), Kokkos::ALL()); - auto sbb = Kokkos::subview(sb, k, Kokkos::ALL(), Kokkos::ALL()); + auto saa = Kokkos::subview(sa, k, Kokkos::ALL(), Kokkos::ALL()); + auto sbb = Kokkos::subview(sb, k, Kokkos::ALL(), Kokkos::ALL()); - TeamCopy::invoke(member, aa, saa); - TeamCopy::invoke(member, bb, sbb); - member.team_barrier(); + TeamCopy::invoke(member, aa, saa); + TeamCopy::invoke(member, bb, sbb); + member.team_barrier(); - TeamGemm:: - invoke(member, 1.0, saa, sbb, 1.0, cc); - } - }); - } + TeamGemm:: + invoke(member, 1.0, saa, sbb, 1.0, cc); + } + }); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagHandmade &, const MemberType &member) const { - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_c.extent(0))) { - const int m = _c.extent(1), n = _c.extent(2), q = _a.extent(2); - Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n), - [&](const int &ij) { - const int i = ij%m, j = ij/m; - typename ViewType::non_const_value_type cval = 0; - for (int p=0;p + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagHandmade &, const MemberType &member) const { + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for(Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_c.extent(0))) { + const int m = _c.extent(1), n = _c.extent(2), q = _a.extent(2); + Kokkos::parallel_for(Kokkos::TeamThreadRange(member,0,m*n), + [&](const int &ij) { + const int i = ij%m, j = ij/m; + typename ViewType::non_const_value_type cval = 0; + for (int p=0;p - void Gemm(const int NN, const int BlkSize) { - typedef Kokkos::Schedule ScheduleType; + template + void Gemm(const int NN, const int BlkSize) { + typedef Kokkos::Schedule ScheduleType; - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; - std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; - } + std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + } - const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize,BlkSize); - const double tmax = 1.0e15; + const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize,BlkSize); + const double tmax = 1.0e15; - typedef Kokkos::DefaultHostExecutionSpace HostSpaceType; - typedef typename DeviceSpaceType::memory_space DeviceMemorySpaceType; + typedef Kokkos::DefaultHostExecutionSpace HostSpaceType; + typedef typename DeviceSpaceType::memory_space DeviceMemorySpaceType; - const int iter_begin = -3, iter_end = 30; - Kokkos::Impl::Timer timer; + const int iter_begin = -3, iter_end = 30; + Kokkos::Impl::Timer timer; - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize), - bmat("bmat", N*VectorLength, BlkSize, BlkSize), - cref("cref", N*VectorLength, BlkSize, BlkSize); + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize), + bmat("bmat", N*VectorLength, BlkSize, BlkSize), + cref("cref", N*VectorLength, BlkSize, BlkSize); - { - Random random; - for (int k=0;k random; + for (int k=0;k flush; + // P100 L2 cache 4MB per core + constexpr size_t LLC_CAPACITY = 56*4*1024*1024; + Flush flush; #if defined(__KOKKOSKERNELS_NVIDIA_CUBLAS__) - if (1) { - /// - /// CUBLAS Strided version - /// - const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, - BlkSize, 1, - BlkSize, BlkSize); - - Kokkos::View - a("a", stride), - b("b", stride), - c("c", stride); + if (1) { + /// + /// CUBLAS Strided version + /// + const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, + BlkSize, 1, + BlkSize, BlkSize); - double tavg = 0, tmin = tmax; + Kokkos::View + a("a", stride), + b("b", stride), + c("c", stride); - cublasStatus_t stat; - cublasHandle_t handle; + double tavg = 0, tmin = tmax; - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - Kokkos::abort("CUBLAS initialization failed\n"); + cublasStatus_t stat; + cublasHandle_t handle; - auto amat_device = Kokkos::create_mirror_view(DeviceMemorySpaceType(), amat); - auto bmat_device = Kokkos::create_mirror_view(DeviceMemorySpaceType(), bmat); + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) + Kokkos::abort("CUBLAS initialization failed\n"); - Kokkos::deep_copy(amat_device, amat); - Kokkos::deep_copy(bmat_device, bmat); + auto amat_device = Kokkos::create_mirror_view(DeviceMemorySpaceType(), amat); + auto bmat_device = Kokkos::create_mirror_view(DeviceMemorySpaceType(), bmat); - DeviceSpaceType::fence(); + Kokkos::deep_copy(amat_device, amat); + Kokkos::deep_copy(bmat_device, bmat); - const double one(1.0), zero(0.0); - { - tavg = 0; tmin = tmax; + DeviceSpaceType::fence(); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); - Kokkos::deep_copy(csol, c); - Kokkos::deep_copy(cref, csol); - - std::cout << std::setw(8) << "CUBLAS" - << std::setw(8) << "Strided" - << " BlkSize = " << std::setw(3) << BlkSize - << " TeamSize = N/A" - << " ScratchSize (KB) = 0" - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin) - << std::endl; + const double one(1.0), zero(0.0); + { + tavg = 0; tmin = tmax; + + for (int iter=iter_begin;iter= 0)*t; } - cublasDestroy(handle); + tavg /= iter_end; + + auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); + Kokkos::deep_copy(csol, c); + Kokkos::deep_copy(cref, csol); + + std::cout << std::setw(8) << "CUBLAS" + << std::setw(8) << "Strided" + << " BlkSize = " << std::setw(3) << BlkSize + << " TeamSize = N/A" + << " ScratchSize (KB) = 0" + << " time = " << std::scientific << tmin + << " avg flop/s = " << (flop/tavg) + << " max flop/s = " << (flop/tmin) + << std::endl; } + cublasDestroy(handle); + } #endif - if (1) { - /// - /// Range policy version - /// - typedef Kokkos::View view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, BlkSize), - c("c", N*VectorLength, BlkSize, BlkSize); - - double tavg = 0, tmin = tmax; - { - typedef Functor functor_type; - const Kokkos::RangePolicy policy(0, N*VectorLength); + if (1) { + /// + /// Range policy version + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); + + double tavg = 0, tmin = tmax; + { + typedef Functor functor_type; + const Kokkos::RangePolicy policy(0, N*VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); - Kokkos::deep_copy(csol, c); - - double diff = 0; - for (int i=0,iend=cref.extent(0);i view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; + typedef Functor functor_type; - // 128 is rough estimates - const int team_size = - policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); + // 128 is rough estimates + const int team_size = + policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); - const policy_type policy(N/team_size, team_size, VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; + + auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); + Kokkos::deep_copy(csol, c); + + double diff = 0; + for (int i=0,iend=cref.extent(0);i policy_type; + typedef Functor functor_type; - double diff = 0; - for (int i=0,iend=cref.extent(0);i::value), + mb = Algo::Gemm::Blocked::mb(), + mp = BlkSize%mb > 0; - std::cout << std::setw(8) << "Kokkos" - << std::setw(8) << "Team V1" - << " BlkSize = " << std::setw(3) << BlkSize - << " TeamSize = " << std::setw(3) << team_size - << " ScratchSize (KB) = 0" - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin); + const int + mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; + + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + const int team_size = std::min(std::max(mblk*mblk,4), max_team_size); + + policy_type policy(N, team_size, VectorLength); + for (int iter=iter_begin;iter= 0)*t; + } + tavg /= iter_end; + + auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); + Kokkos::deep_copy(csol, c); + + double diff = 0; + for (int i=0,iend=cref.extent(0);i policy_type; - typedef Functor functor_type; + if (1) { + /// + /// Team policy V3 - team parallel + scratch + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); + + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; + const int lvl = 0, per_team_scratch = 2*ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); + //std::cout << "per team scratch " << per_team_scratch << "\n"; + if (per_team_scratch/1024 < 48) { const int is_blocked_algo = (std::is_same::value), mb = Algo::Gemm::Blocked::mb(), @@ -432,12 +507,13 @@ namespace KokkosBatched { const int mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; - - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) + .team_size_max(functor_type(), Kokkos::ParallelForTag()); const int team_size = std::min(std::max(mblk*mblk,4), max_team_size); - - policy_type policy(N, team_size, VectorLength); + + policy_type policy = policy_type(N, team_size, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)); for (int iter=iter_begin;iter view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, BlkSize), - c("c", N*VectorLength, BlkSize, BlkSize); - - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; - - const int lvl = 0, per_team_scratch = 2*ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); - //std::cout << "per team scratch " << per_team_scratch << "\n"; - if (per_team_scratch/1024 < 48) { - const int - is_blocked_algo = (std::is_same::value), - mb = Algo::Gemm::Blocked::mb(), - mp = BlkSize%mb > 0; - - const int - mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; - - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) - .team_size_max(functor_type(), Kokkos::ParallelForTag()); - const int team_size = std::min(std::max(mblk*mblk,4), max_team_size); - - policy_type policy = policy_type(N, team_size, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); - Kokkos::deep_copy(csol, c); - - double diff = 0; - for (int i=0,iend=cref.extent(0);i view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, BlkSize), - c("c", N*VectorLength, BlkSize, BlkSize); + if (1) { + /// + /// Team policy - handmade + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); + + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + const int team_size = std::min(max_team_size,BlkSize*BlkSize); - const int team_size = std::min(max_team_size,BlkSize*BlkSize); + const policy_type policy(N, team_size, VectorLength); + for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto csol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), c); - Kokkos::deep_copy(csol, c); - - double diff = 0; - for (int i=0,iend=cref.extent(0);i >::value) value_type_name = "Kokkos::complex"; + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; #if defined(__AVX512F__) - std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #elif defined(__AVX__) || defined(__AVX2__) - std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #else - std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #endif - } - - const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize,BlkSize); - const double tmax = 1.0e15; - - const int iter_begin = -10, iter_end = 100; - Kokkos::Impl::Timer timer; - - Kokkos::View cref; - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize), - bmat("bmat", N*VectorLength, BlkSize, BlkSize); - - Kokkos::Random_XorShift64_Pool random(13718); - Kokkos::fill_random(amat, random, value_type(1.0)); - Kokkos::fill_random(bmat, random, value_type(1.0)); + } - typedef Vector,VectorLength> VectorType; - Kokkos::View - amat_simd("amat_simd", N, BlkSize, BlkSize), - bmat_simd("bmat_simd", N, BlkSize, BlkSize); - - Kokkos::parallel_for("KokkosBatched::PerfTest::GemmHost::Pack", - Kokkos::RangePolicy(0, N*VectorLength), - KOKKOS_LAMBDA(const int k) { - const int k0 = k/VectorLength, k1 = k%VectorLength; - for (int i=0;i cref; + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize), + bmat("bmat", N*VectorLength, BlkSize, BlkSize); + + Kokkos::Random_XorShift64_Pool random(13718); + Kokkos::fill_random(amat, random, value_type(1.0)); + Kokkos::fill_random(bmat, random, value_type(1.0)); + + typedef Vector,VectorLength> VectorType; + Kokkos::View + amat_simd("amat_simd", N, BlkSize, BlkSize), + bmat_simd("bmat_simd", N, BlkSize, BlkSize); + + Kokkos::parallel_for("KokkosBatched::PerfTest::GemmHost::Pack", + Kokkos::RangePolicy(0, N*VectorLength), + KOKKOS_LAMBDA(const int k) { + const int k0 = k/VectorLength, k1 = k%VectorLength; + for (int i=0;i flush; + // for KNL (1MB per tile) + constexpr size_t LLC_CAPACITY = 34*1024*1024; + Flush flush; - /// - /// Reference version using MKL DGEMM - /// + /// + /// Reference version using MKL DGEMM + /// #if defined(__KOKKOSBATCHED_INTEL_MKL__) - { - Kokkos::View - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, BlkSize), - c("c", N*VectorLength, BlkSize, BlkSize); + { + Kokkos::View + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); - { - const Kokkos::RangePolicy policy(0, N*VectorLength); + { + const Kokkos::RangePolicy policy(0, N*VectorLength); - double tavg = 0, tmin = tmax; - for (int iter=iter_begin;iter::value) { - cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, - BlkSize, BlkSize, BlkSize, - one, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0(), - one, - (double*)cc.data(), cc.stride_0()); - } else if (std::is_same >::value) { - cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, - BlkSize, BlkSize, BlkSize, - (void*)&one, - (void*)aa.data(), aa.stride_0(), - (void*)bb.data(), bb.stride_0(), - (void*)&one, - (void*)cc.data(), cc.stride_0()); - } + const double one = 1.0; + if (std::is_same::value) { + cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, + BlkSize, BlkSize, BlkSize, + one, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0(), + one, + (double*)cc.data(), cc.stride_0()); + } else if (std::is_same >::value) { + cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, + BlkSize, BlkSize, BlkSize, + (void*)&one, + (void*)aa.data(), aa.stride_0(), + (void*)bb.data(), bb.stride_0(), + (void*)&one, + (void*)cc.data(), cc.stride_0()); + } - }); + }); - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - std::cout << std::setw(12) << "MKL DGEMM" - << " BlkSize = " << std::setw(3) << BlkSize - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin) - << std::endl; + std::cout << std::setw(12) << "MKL DGEMM" + << " BlkSize = " << std::setw(3) << BlkSize + << " time = " << std::scientific << tmin + << " avg flop/s = " << (flop/tavg) + << " max flop/s = " << (flop/tmin) + << std::endl; - cref = c; - } + cref = c; } + } #if defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) + { + typedef Kokkos::View ViewType; + ViewType + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); + + value_type + *aa[N*VectorLength], + *bb[N*VectorLength], + *cc[N*VectorLength]; + + for (int k=0;k ViewType; - ViewType - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, BlkSize), - c("c", N*VectorLength, BlkSize, BlkSize); - - value_type - *aa[N*VectorLength], - *bb[N*VectorLength], - *cc[N*VectorLength]; - - for (int k=0;k::value) { + cblas_dgemm_batch(CblasRowMajor, + transA, + transB, + blksize, blksize, blksize, + one, + (const double**)aa, lda, + (const double**)bb, ldb, + one, + (double**)cc, ldc, + 1, size_per_grp); + } else if (std::is_same >::value) { + cblas_zgemm_batch(CblasRowMajor, + transA, + transB, + blksize, blksize, blksize, + one, + (const void**)aa, lda, + (const void**)bb, ldb, + one, + (void**)cc, ldc, + 1, size_per_grp); + } + + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; + + double diff = 0; + for (int i=0,iend=cref.extent(0);i zone(1.0); + + MKL_COMPACT_PACK format; + if (std::is_same::value) { + if (VectorLength == 4) format = MKL_COMPACT_AVX; + else if (VectorLength == 8) format = MKL_COMPACT_AVX512; + } else if (std::is_same >::value) { + if (VectorLength == 2) format = MKL_COMPACT_AVX; + else if (VectorLength == 4) format = MKL_COMPACT_AVX512; + } + if (format == MKL_COMPACT_AVX512 || format == MKL_COMPACT_AVX) { for (int iter=iter_begin;iter::value) { - cblas_dgemm_batch(CblasRowMajor, - transA, - transB, - blksize, blksize, blksize, - one, - (const double**)aa, lda, - (const double**)bb, ldb, - one, - (double**)cc, ldc, - 1, size_per_grp); + mkl_dgemm_compact(MKL_ROW_MAJOR, + MKL_NOTRANS, MKL_NOTRANS, + BlkSize, BlkSize, BlkSize, + done, + (const double*)a.data(), (MKL_INT)a.stride_1(), + (const double*)b.data(), (MKL_INT)b.stride_1(), + done, + ( double*)c.data(), (MKL_INT)c.stride_1(), + format, N*VectorLength); } else if (std::is_same >::value) { - cblas_zgemm_batch(CblasRowMajor, - transA, - transB, - blksize, blksize, blksize, - one, - (const void**)aa, lda, - (const void**)bb, ldb, - one, - (void**)cc, ldc, - 1, size_per_grp); + mkl_zgemm_compact(MKL_ROW_MAJOR, + MKL_NOTRANS, MKL_NOTRANS, + BlkSize, BlkSize, BlkSize, + (MKL_Complex16*)&zone, + (const double*)a.data(), (MKL_INT)a.stride_1(), + (const double*)b.data(), (MKL_INT)b.stride_1(), + (MKL_Complex16*)&zone, + ( double*)c.data(), (MKL_INT)c.stride_1(), + format, N*VectorLength); } - + HostSpaceType::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; } tavg /= iter_end; - + double diff = 0; for (int i=0,iend=cref.extent(0);i zone(1.0); - - MKL_COMPACT_PACK format; - if (std::is_same::value) { - if (VectorLength == 4) format = MKL_COMPACT_AVX; - else if (VectorLength == 8) format = MKL_COMPACT_AVX512; - } else if (std::is_same >::value) { - if (VectorLength == 2) format = MKL_COMPACT_AVX; - else if (VectorLength == 4) format = MKL_COMPACT_AVX512; - } - - if (format == MKL_COMPACT_AVX512 || format == MKL_COMPACT_AVX) { - for (int iter=iter_begin;iter::value) { - mkl_dgemm_compact(MKL_ROW_MAJOR, - MKL_NOTRANS, MKL_NOTRANS, - BlkSize, BlkSize, BlkSize, - done, - (const double*)a.data(), (MKL_INT)a.stride_1(), - (const double*)b.data(), (MKL_INT)b.stride_1(), - done, - ( double*)c.data(), (MKL_INT)c.stride_1(), - format, N*VectorLength); - } else if (std::is_same >::value) { - mkl_zgemm_compact(MKL_ROW_MAJOR, - MKL_NOTRANS, MKL_NOTRANS, - BlkSize, BlkSize, BlkSize, - (MKL_Complex16*)&zone, - (const double*)a.data(), (MKL_INT)a.stride_1(), - (const double*)b.data(), (MKL_INT)b.stride_1(), - (MKL_Complex16*)&zone, - ( double*)c.data(), (MKL_INT)c.stride_1(), - format, N*VectorLength); - } - - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; - - double diff = 0; - for (int i=0,iend=cref.extent(0);i + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, BlkSize), + c("c", N*VectorLength, BlkSize, BlkSize); - libxsmm_blasint - lda = a.stride_1(), - ldb = b.stride_1(), - ldc = c.stride_1(); + libxsmm_blasint + lda = a.stride_1(), + ldb = b.stride_1(), + ldc = c.stride_1(); - { - const Kokkos::RangePolicy policy(0, N*VectorLength); + { + const Kokkos::RangePolicy policy(0, N*VectorLength); - double tavg = 0, tmin = tmax; - - // adjust column major order in xsmm - char transA = 'N', transB = 'N'; - libxsmm_blasint blksize = BlkSize; - double one = 1.0; - - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - // adjust transpose - double diff = 0; - for (int i=0,iend=cref.extent(0);i policy(0, N*VectorLength); + /// + /// Do not test this. Test Compact vs MKL + /// KK Scalar version (comparable to micro BLAS version) + /// + // if (!std::is_same::value) { + // Kokkos::View + // a("a", N*VectorLength, BlkSize, BlkSize), + // b("b", N*VectorLength, BlkSize, BlkSize), + // c("c", N*VectorLength, BlkSize, BlkSize); + + // { + // const Kokkos::RangePolicy policy(0, N*VectorLength); - // double tavg = 0, tmin = tmax; - - // for (int iter=iter_begin;iter:: - // invoke(1.0, aa, bb, 1.0, cc); - // }); + // SerialGemm:: + // invoke(1.0, aa, bb, 1.0, cc); + // }); - // HostSpaceType::fence(); - // const double t = timer.seconds(); - // tmin = std::min(tmin, t); - // tavg += (iter >= 0)*t; - // } - // tavg /= iter_end; - - // double diff = 0; - // for (int i=0,iend=cref.extent(2);i= 0)*t; + // } + // tavg /= iter_end; + + // double diff = 0; + // for (int i=0,iend=cref.extent(2);i policy(0, N); + { + const Kokkos::RangePolicy policy(0, N); - double tavg = 0, tmin = tmax; - - for (int iter=iter_begin;iter:: - invoke(1.0, aa, bb, 1.0, cc); - }); + SerialGemm:: + invoke(1.0, aa, bb, 1.0, cc); + }); - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; - - double diff = 0; - for (int i=0,iend=cref.extent(0);i void run(const int N) { diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp b/perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp index b24139dcd5..7bb2a2907c 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp +++ b/perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp @@ -3,7 +3,7 @@ #define KokkosBatched_Test_Gemm_Host_Real 1 #include "KokkosBatched_Test_Gemm_Host.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; template void run(const int N) { diff --git a/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp b/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp index 94dbd3efdd..b22e65769d 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp @@ -22,8 +22,7 @@ #undef __KOKKOSBATCHED_INTEL_MKL_BATCHED__ namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #undef FLOP_MUL #undef FLOP_ADD @@ -31,260 +30,259 @@ namespace KokkosBatched { #if defined( KokkosBatched_Test_Gemv_Host_Complex ) #define FLOP_MUL 6.0 #define FLOP_ADD 2.0 - typedef Kokkos::complex value_type; + typedef Kokkos::complex value_type; #endif #if defined( KokkosBatched_Test_Gemv_Host_Real ) #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; #endif - double FlopCount(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - return (FLOP_MUL*(m*n) + - FLOP_ADD*(m*n)); - } + double FlopCount(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + return (FLOP_MUL*(m*n) + + FLOP_ADD*(m*n)); + } - template - void Gemv(const int NN) { - typedef Kokkos::Schedule ScheduleType; - //typedef Kokkos::Schedule ScheduleType; + template + void Gemv(const int NN) { + typedef Kokkos::Schedule ScheduleType; + //typedef Kokkos::Schedule ScheduleType; - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; #if defined(__AVX512F__) - std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #elif defined(__AVX__) || defined(__AVX2__) - std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #else - std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #endif - } + } - const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize)*NumVecs; - //const double tmax = 1.0e15; + const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize)*NumVecs; + //const double tmax = 1.0e15; - const int iter_begin = -10, iter_end = 100; - Kokkos::Impl::Timer timer; + const int iter_begin = -10, iter_end = 100; + Kokkos::Impl::Timer timer; - Kokkos::View yref; - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize); - Kokkos::View - xvec("xvec", N*VectorLength, NumVecs, BlkSize); - - Kokkos::Random_XorShift64_Pool random(13718); - Kokkos::fill_random(xvec, random, value_type(1.0)); - Kokkos::fill_random(amat, random, value_type(1.0)); + Kokkos::View yref; + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize); + Kokkos::View + xvec("xvec", N*VectorLength, NumVecs, BlkSize); + + Kokkos::Random_XorShift64_Pool random(13718); + Kokkos::fill_random(xvec, random, value_type(1.0)); + Kokkos::fill_random(amat, random, value_type(1.0)); - // for KNL - constexpr size_t LLC_CAPACITY = 34*1024*1024; - Flush flush; + // for KNL + constexpr size_t LLC_CAPACITY = 34*1024*1024; + Flush flush; - /// - /// Reference version using MKL DGEMM - /// + /// + /// Reference version using MKL DGEMM + /// #if defined(__KOKKOSBATCHED_INTEL_MKL__) - { - Kokkos::View - a("a", N*VectorLength, BlkSize, BlkSize), - x("x", N*VectorLength, NumVecs, BlkSize), - y("y", N*VectorLength, NumVecs, BlkSize); + { + Kokkos::View + a("a", N*VectorLength, BlkSize, BlkSize), + x("x", N*VectorLength, NumVecs, BlkSize), + y("y", N*VectorLength, NumVecs, BlkSize); - { - const Kokkos::RangePolicy policy(0, N*VectorLength); + { + const Kokkos::RangePolicy policy(0, N*VectorLength); - double t = 0; - for (int iter=iter_begin;iter= 0)*timer.seconds(); - } - t /= iter_end; - - std::cout << std::setw(12) << "MKL DGEMV" - << " BlkSize = " << std::setw(3) << BlkSize - << " NumVecs = " << std::setw(3) << NumVecs - << " time = " << std::scientific << t - << " flop/s = " << (flop/t) - << std::endl; - - yref = y; + HostSpaceType::fence(); + t += (iter >= 0)*timer.seconds(); } + t /= iter_end; + + std::cout << std::setw(12) << "MKL DGEMV" + << " BlkSize = " << std::setw(3) << BlkSize + << " NumVecs = " << std::setw(3) << NumVecs + << " time = " << std::scientific << t + << " flop/s = " << (flop/t) + << std::endl; + + yref = y; } + } #endif - /// - /// Plain version (comparable to micro BLAS version) - /// - { - Kokkos::View - a("a", N*VectorLength, BlkSize, BlkSize), - x("x", N*VectorLength, NumVecs, BlkSize), - y("y", N*VectorLength, NumVecs, BlkSize); + /// + /// Plain version (comparable to micro BLAS version) + /// + { + Kokkos::View + a("a", N*VectorLength, BlkSize, BlkSize), + x("x", N*VectorLength, NumVecs, BlkSize), + y("y", N*VectorLength, NumVecs, BlkSize); - { - const Kokkos::RangePolicy policy(0, N*VectorLength); + { + const Kokkos::RangePolicy policy(0, N*VectorLength); - double t = 0; - for (int iter=iter_begin;iter:: - invoke(1.0, aa, xx, 1.0, yy); - } - }); + SerialGemv:: + invoke(1.0, aa, xx, 1.0, yy); + } + }); - HostSpaceType::fence(); - t += (iter >= 0)*timer.seconds(); - } - t /= iter_end; - - double diff = 0; - for (int i=0,iend=yref.extent(0);i,VectorLength> VectorType; + Kokkos::View + amat_simd("amat_simd", N, BlkSize, BlkSize), + xvec_simd("xvec_simd", N, NumVecs, BlkSize); - for (int k0=0;k0 - a("a", N, BlkSize, BlkSize), - x("x", N, NumVecs, BlkSize), - y("y", N, NumVecs, BlkSize); + /// + /// Serial SIMD with appropriate data layout + /// + { + Kokkos::View + a("a", N, BlkSize, BlkSize), + x("x", N, NumVecs, BlkSize), + y("y", N, NumVecs, BlkSize); - { - const Kokkos::RangePolicy policy(0, N); + { + const Kokkos::RangePolicy policy(0, N); - double t = 0; - for (int iter=iter_begin;iter:: - invoke(1.0, aa, xx, 1.0, yy); - } - }); + SerialGemv:: + invoke(1.0, aa, xx, 1.0, yy); + } + }); - HostSpaceType::fence(); - t += (iter >= 0)*timer.seconds(); - } - t /= iter_end; - - double diff = 0; - for (int i=0,iend=yref.extent(0);i void run(const int N) { diff --git a/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp index 374d0e1a22..4c2da01804 100644 --- a/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp @@ -23,387 +23,458 @@ #include "KokkosBatched_LU_Team_Impl.hpp" namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; - double FlopCount(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - if (m > n) - return (FLOP_MUL*(0.5*m*n*n-(1.0/6.0)*n*n*n+0.5*m*n-0.5*n*n+(2.0/3.0)*n) + - FLOP_ADD*(0.5*m*n*n-(1.0/6.0)*n*n*n-0.5*m*n+ (1.0/6.0)*n)); - else - return (FLOP_MUL*(0.5*n*m*m-(1.0/6.0)*m*m*m+0.5*n*m-0.5*m*m+(2.0/3.0)*m) + - FLOP_ADD*(0.5*n*m*m-(1.0/6.0)*m*m*m-0.5*n*m+ (1.0/6.0)*m)); - } + double FlopCount(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + if (m > n) + return (FLOP_MUL*(0.5*m*n*n-(1.0/6.0)*n*n*n+0.5*m*n-0.5*n*n+(2.0/3.0)*n) + + FLOP_ADD*(0.5*m*n*n-(1.0/6.0)*n*n*n-0.5*m*n+ (1.0/6.0)*n)); + else + return (FLOP_MUL*(0.5*n*m*m-(1.0/6.0)*m*m*m+0.5*n*m-0.5*m*m+(2.0/3.0)*m) + + FLOP_ADD*(0.5*n*m*m-(1.0/6.0)*m*m*m-0.5*n*m+ (1.0/6.0)*m)); + } - struct RangeTag {}; - struct TeamTagV1 {}; - struct TeamTagV2 {}; - struct TeamTagV3 {}; - struct TeamTagHandmade {}; + struct RangeTag {}; + struct TeamTagV1 {}; + struct TeamTagV2 {}; + struct TeamTagV3 {}; + struct TeamTagHandmade {}; - template - struct Functor { - UnmanagedViewType _a; + template + struct Functor { + UnmanagedViewType _a; - KOKKOS_INLINE_FUNCTION - Functor() = default; + KOKKOS_INLINE_FUNCTION + Functor() = default; - KOKKOS_INLINE_FUNCTION - Functor(const ViewType &a) - : _a(a) {} + KOKKOS_INLINE_FUNCTION + Functor(const ViewType &a) + : _a(a) {} - KOKKOS_INLINE_FUNCTION - void operator()(const RangeTag &, const int k) const { - auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); - SerialLU::invoke(aa); - } + KOKKOS_INLINE_FUNCTION + void operator()(const RangeTag &, const int k) const { + auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); + SerialLU::invoke(aa); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV1 &, const MemberType &member) const { - const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + - member.team_rank()*VectorLength); - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < _a.extent_int(0)) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - SerialLU::invoke(aa); - } - }); - } + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV1 &, const MemberType &member) const { + const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + + member.team_rank()*VectorLength); + Kokkos::parallel_for + (Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < _a.extent_int(0)) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + SerialLU::invoke(aa); + } + }); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV2 &, const MemberType &member) const { - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < _a.extent_int(0)) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - TeamLU::invoke(member, aa); - } - }); - } + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV2 &, const MemberType &member) const { + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for + (Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < _a.extent_int(0)) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + TeamLU::invoke(member, aa); + } + }); + } - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV3 &, const MemberType &member) const { - const int lvl = 0; - ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV3 &, const MemberType &member) const { + const int lvl = 0; + ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < _a.extent_int(0)) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto saa = Kokkos::subview(sa, k, Kokkos::ALL(), Kokkos::ALL()); - - TeamCopy::invoke(member, aa, saa); - member.team_barrier(); - TeamLU::invoke(member, saa); - member.team_barrier(); - TeamCopy::invoke(member, saa, aa); - } - }); - } + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for + (Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < _a.extent_int(0)) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto saa = Kokkos::subview(sa, k, Kokkos::ALL(), Kokkos::ALL()); + + TeamCopy::invoke(member, aa, saa); + member.team_barrier(); + TeamLU::invoke(member, saa); + member.team_barrier(); + TeamCopy::invoke(member, saa, aa); + } + }); + } - }; + }; - template - void LU(const int NN, const int BlkSize) { - typedef Kokkos::Schedule ScheduleType; + template + void LU(const int NN, const int BlkSize) { + typedef Kokkos::Schedule ScheduleType; - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; - std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; - } - - const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize); - const double tmax = 1.0e15; - - typedef Kokkos::DefaultHostExecutionSpace HostSpaceType; - typedef typename DeviceSpaceType::memory_space DeviceMemorySpaceType; - - const int iter_begin = -3, iter_end = 50; - Kokkos::Impl::Timer timer; - - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize), - aref("aref", N*VectorLength, BlkSize, BlkSize); + std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + } - { - Random random; - for (int k=0;k + amat("amat", N*VectorLength, BlkSize, BlkSize), + aref("aref", N*VectorLength, BlkSize, BlkSize); + + { + Random random; + for (int k=0;k flush; + constexpr size_t LLC_CAPACITY = 56*4*1024*1024; + Flush flush; #if defined(__KOKKOSKERNELS_NVIDIA_CUBLAS__) - if (1) { - /// - /// CUBLAS Batch version - /// - const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, - BlkSize, 1, - BlkSize, BlkSize); + if (1) { + /// + /// CUBLAS Batch version + /// + const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, + BlkSize, 1, + BlkSize, BlkSize); - Kokkos::View a("a", stride); - Kokkos::View info("info", N*VectorLength); + Kokkos::View a("a", stride); + Kokkos::View info("info", N*VectorLength); - cublasStatus_t stat; - cublasHandle_t handle; + cublasStatus_t stat; + cublasHandle_t handle; - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - Kokkos::abort("CUBLAS initialization failed\n"); + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) + Kokkos::abort("CUBLAS initialization failed\n"); - auto amat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), amat); - Kokkos::deep_copy(amat_device, amat); - - DeviceSpaceType::fence(); - { - double tavg = 0, tmin = tmax; - value_type *aa[N*VectorLength]; - - for (int k=0;k= 0)*t; + // initialize matrix + Kokkos::deep_copy(a, amat_device); + + DeviceSpaceType::fence(); + timer.reset(); + + stat = cublasDgetrfBatched(handle, + BlkSize, + (value_type**)aa_device, BlkSize, + NULL, + (int*)info.data(), + N*VectorLength); + if (stat != CUBLAS_STATUS_SUCCESS) { + Kokkos::abort("CUBLAS LU Batched failed\n"); } - tavg /= iter_end; - - auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); - Kokkos::deep_copy(asol, a); - Kokkos::deep_copy(aref, asol); + + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - if (cudaFree(aa_device) != cudaSuccess) { - Kokkos::abort("CUDA memory free failed\n"); - } + auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); + Kokkos::deep_copy(asol, a); + Kokkos::deep_copy(aref, asol); - std::cout << std::setw(8) << "CUBLAS" - << std::setw(8) << "Batch" - << " BlkSize = " << std::setw(3) << BlkSize - << " TeamSize = N/A" - << " ScratchSize (KB) = N/A" - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin) - << std::endl; + if (cudaFree(aa_device) != cudaSuccess) { + Kokkos::abort("CUDA memory free failed\n"); } + + std::cout << std::setw(8) << "CUBLAS" + << std::setw(8) << "Batch" + << " BlkSize = " << std::setw(3) << BlkSize + << " TeamSize = N/A" + << " ScratchSize (KB) = N/A" + << " time = " << std::scientific << tmin + << " avg flop/s = " << (flop/tavg) + << " max flop/s = " << (flop/tmin) + << std::endl; } + } #endif - if (1) { - /// - /// Range policy version - /// - typedef Kokkos::View view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize); + if (1) { + /// + /// Range policy version + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize); - double tavg = 0, tmin = tmax; - { - typedef Functor functor_type; - const Kokkos::RangePolicy policy(0, N*VectorLength); + double tavg = 0, tmin = tmax; + { + typedef Functor functor_type; + const Kokkos::RangePolicy policy(0, N*VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); - Kokkos::deep_copy(asol, a); + auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); + Kokkos::deep_copy(asol, a); - double diff = 0; - for (int i=0,iend=aref.extent(0);i policy_type; + typedef Functor functor_type; + + const int team_size = + policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); + + const policy_type policy(N/team_size, team_size, VectorLength); + for (int iter=iter_begin;iter= 0)*t; } + tavg /= iter_end; + + auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); + Kokkos::deep_copy(asol, a); + + double diff = 0; + for (int i=0,iend=aref.extent(0);i view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize); + + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; + const int + is_blocked_algo = (std::is_same::value), + mb = Algo::LU::Blocked::mb(); + //mp = BlkSize%mb > 0; - const int team_size = - policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); + const int + //mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; + mblk = is_blocked_algo ? (BlkSize - mb) : (BlkSize - 1); - const policy_type policy(N/team_size, team_size, VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; + Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV2", policy, functor_type(a)); + + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); - Kokkos::deep_copy(asol, a); + auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); + Kokkos::deep_copy(asol, a); - double diff = 0; - for (int i=0,iend=aref.extent(0);i policy_type; - typedef Functor functor_type; + } + if (1) { + /// + /// Team V3 + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize); + + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; + const int lvl = 0, per_team_scratch = ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); + if (per_team_scratch/1024 < 48) { const int is_blocked_algo = (std::is_same::value), mb = Algo::LU::Blocked::mb(); - //mp = BlkSize%mb > 0; + // mp = BlkSize%mb > 0; const int //mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; mblk = is_blocked_algo ? (BlkSize - mb) : (BlkSize - 1); - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) + .team_size_max(functor_type(), Kokkos::ParallelForTag()); const int team_size = std::min(std::max(mblk*2,1), max_team_size); - const policy_type policy(N, team_size, VectorLength); + policy_type policy(N, team_size, VectorLength); for (int iter=iter_begin;iter view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize); - - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; - - const int lvl = 0, per_team_scratch = ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); - if (per_team_scratch/1024 < 48) { - const int - is_blocked_algo = (std::is_same::value), - mb = Algo::LU::Blocked::mb(); - // mp = BlkSize%mb > 0; - - const int - //mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; - mblk = is_blocked_algo ? (BlkSize - mb) : (BlkSize - 1); - - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) - .team_size_max(functor_type(), Kokkos::ParallelForTag()); - const int team_size = std::min(std::max(mblk*2,1), max_team_size); - - policy_type policy(N, team_size, VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto asol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), a); - Kokkos::deep_copy(asol, a); - - double diff = 0; - for (int i=0,iend=aref.extent(0);i void run(const int N, const int B) { diff --git a/perf_test/batched/KokkosBatched_Test_LU_Host.hpp b/perf_test/batched/KokkosBatched_Test_LU_Host.hpp index fb43ad39e5..34371f2a98 100644 --- a/perf_test/batched/KokkosBatched_Test_LU_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_LU_Host.hpp @@ -20,302 +20,195 @@ #undef __KOKKOSBATCHED_INTEL_MKL_BATCHED__ namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #undef FLOP_MUL #undef FLOP_ADD - // no complex yet + // no complex yet #if defined( KokkosBatched_Test_LU_Host_Complex ) #define FLOP_MUL 6.0 #define FLOP_ADD 2.0 - typedef Kokkos::complex value_type; + typedef Kokkos::complex value_type; #endif #if defined( KokkosBatched_Test_LU_Host_Real ) #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; #endif - double FlopCount(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - if (m > n) - return (FLOP_MUL*(0.5*m*n*n-(1.0/6.0)*n*n*n+0.5*m*n-0.5*n*n+(2.0/3.0)*n) + - FLOP_ADD*(0.5*m*n*n-(1.0/6.0)*n*n*n-0.5*m*n+ (1.0/6.0)*n)); - else - return (FLOP_MUL*(0.5*n*m*m-(1.0/6.0)*m*m*m+0.5*n*m-0.5*m*m+(2.0/3.0)*m) + - FLOP_ADD*(0.5*n*m*m-(1.0/6.0)*m*m*m-0.5*n*m+ (1.0/6.0)*m)); - } - - template - void LU(const int NN) { - typedef Kokkos::Schedule ScheduleType; - //typedef Kokkos::Schedule ScheduleType; - - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; - - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; + double FlopCount(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + if (m > n) + return (FLOP_MUL*(0.5*m*n*n-(1.0/6.0)*n*n*n+0.5*m*n-0.5*n*n+(2.0/3.0)*n) + + FLOP_ADD*(0.5*m*n*n-(1.0/6.0)*n*n*n-0.5*m*n+ (1.0/6.0)*n)); + else + return (FLOP_MUL*(0.5*n*m*m-(1.0/6.0)*m*m*m+0.5*n*m-0.5*m*m+(2.0/3.0)*m) + + FLOP_ADD*(0.5*n*m*m-(1.0/6.0)*m*m*m-0.5*n*m+ (1.0/6.0)*m)); + } + + template + void LU(const int NN) { + typedef Kokkos::Schedule ScheduleType; + //typedef Kokkos::Schedule ScheduleType; + + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; + + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; #if defined(__AVX512F__) - std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #elif defined(__AVX__) || defined(__AVX2__) - std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #else - std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #endif - } + } - const double flop = (N*VectorLength)*FlopCount(BlkSize,BlkSize); - const double tmax = 1.0e15; - - const int iter_begin = -10, iter_end = 100; - Kokkos::Impl::Timer timer; - - /// - /// Reference version using MKL DGETRF - /// - Kokkos::View aref; - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize); - - Random random; - - for (int k=0;k aref; + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize); + + Random random; + + for (int k=0;k,VectorLength> VectorType; - Kokkos::View - amat_simd("amat_simd", N, BlkSize, BlkSize); //, a("a", N, BlkSize, BlkSize); + typedef Vector,VectorLength> VectorType; + Kokkos::View + amat_simd("amat_simd", N, BlkSize, BlkSize); //, a("a", N, BlkSize, BlkSize); - Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::Pack", - Kokkos::RangePolicy(0, N*VectorLength), - KOKKOS_LAMBDA(const int k) { - const int k0 = k/VectorLength, k1 = k%VectorLength; - for (int i=0;i flush; - - /// - /// Reference version using MKL DGETRF - /// + Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::Pack", + Kokkos::RangePolicy(0, N*VectorLength), + KOKKOS_LAMBDA(const int k) { + const int k0 = k/VectorLength, k1 = k%VectorLength; + for (int i=0;i flush; + + /// + /// Reference version using MKL DGETRF + /// #if defined(__KOKKOSBATCHED_INTEL_MKL__) + { + Kokkos::View a("a", N*VectorLength, BlkSize, BlkSize); + Kokkos::View p("p", N*VectorLength, BlkSize); { - Kokkos::View a("a", N*VectorLength, BlkSize, BlkSize); - Kokkos::View p("p", N*VectorLength, BlkSize); - { - double tavg = 0, tmin = tmax; - for (int iter=iter_begin;iter policy(0, N*VectorLength); - Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::LAPACKE_dgetrfOpenMP", - policy, - KOKKOS_LAMBDA(const int k) { - auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - auto pp = Kokkos::subview(p, k, Kokkos::ALL()); - LAPACKE_dgetrf(LAPACK_ROW_MAJOR, - BlkSize, BlkSize, - (double*)aa.data(), aa.stride_0(), - (int*)pp.data()); - }); - - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; - - std::cout << std::setw(10) << "MKL LU" - << " BlkSize = " << std::setw(3) << BlkSize - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin) - << std::endl; + double tavg = 0, tmin = tmax; + for (int iter=iter_begin;iter policy(0, N*VectorLength); + Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::LAPACKE_dgetrfOpenMP", + policy, + KOKKOS_LAMBDA(const int k) { + auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); + auto pp = Kokkos::subview(p, k, Kokkos::ALL()); + LAPACKE_dgetrf(LAPACK_ROW_MAJOR, + BlkSize, BlkSize, + (double*)aa.data(), aa.stride_0(), + (int*)pp.data()); + }); + + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; } - - aref = a; + tavg /= iter_end; + + std::cout << std::setw(10) << "MKL LU" + << " BlkSize = " << std::setw(3) << BlkSize + << " time = " << std::scientific << tmin + << " avg flop/s = " << (flop/tavg) + << " max flop/s = " << (flop/tmin) + << std::endl; } + aref = a; + } + #if defined(__KOKKOSBATCHED_INTEL_MKL_BATCHED__) #endif #if defined(__KOKKOSBATCHED_INTEL_MKL_COMPACT_BATCHED__) - { - Kokkos::View - a("a", N, BlkSize, BlkSize); + { + Kokkos::View + a("a", N, BlkSize, BlkSize); - { - double tavg = 0, tmin = tmax; - MKL_COMPACT_PACK format; - if (VectorLength == 8) format = MKL_COMPACT_AVX512; - else if (VectorLength == 4) format = MKL_COMPACT_AVX; - - if (format == MKL_COMPACT_AVX512 || format == MKL_COMPACT_AVX) { - int info; - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - double diff = 0; - for (int i=0,iend=aref.extent(0);i policy(0, N*VectorLength); - // Kokkos::parallel_for - // (policy, - // KOKKOS_LAMBDA(const int k) { - // auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - - // SerialLU::invoke(aa); - // }); - - // HostSpaceType::fence(); - // const double t = timer.seconds(); - // tmin = std::min(tmin, t); - // tavg += (iter >= 0)*t; - // } - // tavg /= iter_end; - - // double diff = 0; - // for (int i=0,iend=aref.extent(0);i policy(0, N); - Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::SIMDSerialOpenMP", - policy, - KOKKOS_LAMBDA(const int k) { - auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - - SerialLU::invoke(aa); - }); - + + mkl_dgetrfnp_compact(MKL_ROW_MAJOR, + BlkSize, BlkSize, + (double*)a.data(), a.stride_1(), + (MKL_INT*)&info, format, (MKL_INT)N*VectorLength); + HostSpaceType::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; } tavg /= iter_end; - + double diff = 0; for (int i=0,iend=aref.extent(0);i policy(0, N*VectorLength); + // Kokkos::parallel_for + // (policy, + // KOKKOS_LAMBDA(const int k) { + // auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); + + // SerialLU::invoke(aa); + // }); + + // HostSpaceType::fence(); + // const double t = timer.seconds(); + // tmin = std::min(tmin, t); + // tavg += (iter >= 0)*t; + // } + // tavg /= iter_end; + + // double diff = 0; + // for (int i=0,iend=aref.extent(0);i policy(0, N); + Kokkos::parallel_for("KokkosBatched::PerfTest::LUHost::SIMDSerialOpenMP", + policy, + KOKKOS_LAMBDA(const int k) { + auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); + + SerialLU::invoke(aa); + }); + + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; + + double diff = 0; + for (int i=0,iend=aref.extent(0);i void run(const int N) { diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp index d285ad8a34..d13bb215b5 100644 --- a/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp @@ -24,583 +24,659 @@ #include "KokkosBatched_Trsm_Team_Impl.hpp" namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #undef FLOP_MUL #undef FLOP_ADD #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; - double FlopCountLower(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - return (FLOP_MUL*(0.5*m*n*(n+1.0)) + - FLOP_ADD*(0.5*m*n*(n-1.0))); - } + double FlopCountLower(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + return (FLOP_MUL*(0.5*m*n*(n+1.0)) + + FLOP_ADD*(0.5*m*n*(n-1.0))); + } - double FlopCountUpper(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - return (FLOP_MUL*(0.5*m*n*(n+1.0)) + - FLOP_ADD*(0.5*m*n*(n-1.0))); - } + double FlopCountUpper(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + return (FLOP_MUL*(0.5*m*n*(n+1.0)) + + FLOP_ADD*(0.5*m*n*(n-1.0))); + } - struct RangeTag {}; - struct TeamTagV1 {}; - struct TeamTagV2 {}; - struct TeamTagV3 {}; - struct TeamTagHandmade {}; + struct RangeTag {}; + struct TeamTagV1 {}; + struct TeamTagV2 {}; + struct TeamTagV3 {}; + struct TeamTagHandmade {}; - template - struct Functor { - ConstUnmanagedViewType _a; - UnmanagedViewType _b; - - KOKKOS_INLINE_FUNCTION - Functor() = default; - - KOKKOS_INLINE_FUNCTION - Functor(const ViewType &a, - const ViewType &b) - : _a(a), _b(b) {} - - KOKKOS_INLINE_FUNCTION - void operator()(const RangeTag &, const int k) const { - auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - - switch (test) { - case 0: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 1: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 2: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 3: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 4: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - } - } - - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV1 &, const MemberType &member) const { - const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + - member.team_rank()*VectorLength); - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_b.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - - switch (test) { - case 0: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 1: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 2: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 3: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 4: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - } - } - }); - } - - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV2 &, const MemberType &member) const { - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_b.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - - switch (test) { - case 0: - TeamTrsm:: - invoke(member, 1.0, aa, bb); - break; - case 1: - TeamTrsm:: - invoke(member, 1.0, aa, bb); - break; - case 2: - TeamTrsm:: - invoke(member, 1.0, aa, bb); - break; - case 3: - TeamTrsm:: - invoke(member, 1.0, aa, bb); - break; - case 4: - TeamTrsm:: - invoke(member, 1.0, aa, bb); - break; - } - } - }); - } - - template - KOKKOS_INLINE_FUNCTION - void operator()(const TeamTagV3 &, const MemberType &member) const { - const int lvl = 0; - ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); - //ScratchViewType sb(member.team_scratch(lvl), VectorLength, _b.extent(1), _b.extent(2)); - - const int kbeg = member.league_rank()*VectorLength; - Kokkos::parallel_for - (Kokkos::ThreadVectorRange(member, VectorLength), - [&](const int &k) { - const int kk = kbeg + k; - if (kk < int(_b.extent(0))) { - auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - - auto saa = Kokkos::subview(sa, k, Kokkos::ALL(), Kokkos::ALL()); - - TeamCopy::invoke(member, aa, saa); - member.team_barrier(); - - switch (test) { - case 0: - TeamTrsm:: - invoke(member, 1.0, saa, bb); - break; - case 1: - TeamTrsm:: - invoke(member, 1.0, saa, bb); - break; - case 2: - TeamTrsm:: - invoke(member, 1.0, saa, bb); - break; - case 3: - TeamTrsm:: - invoke(member, 1.0, saa, bb); - break; - case 4: - TeamTrsm:: - invoke(member, 1.0, saa, bb); - break; - } - } - }); - } + template + struct Functor { + ConstUnmanagedViewType _a; + UnmanagedViewType _b; - }; + KOKKOS_INLINE_FUNCTION + Functor() = default; + KOKKOS_INLINE_FUNCTION + Functor(const ViewType &a, + const ViewType &b) + : _a(a), _b(b) {} - template - void Trsm(const int NN, const int BlkSize, const int NumCols) { - typedef Kokkos::Schedule ScheduleType; + KOKKOS_INLINE_FUNCTION + void operator()(const RangeTag &, const int k) const { + auto aa = Kokkos::subview(_a, k, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, k, Kokkos::ALL(), Kokkos::ALL()); - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; - - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; - - std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; - } - - switch (test) { - case 0: std::cout << "TestID = Left, Lower, NoTrans, UnitDiag\n"; break; - case 1: std::cout << "TestID = Left, Lower, NoTrans, NonUnitDiag\n"; break; - case 2: std::cout << "TestID = Right, Upper, NoTrans, UnitDiag\n"; break; - case 3: std::cout << "TestID = Right, Upper, NoTrans, NonUnitDiag\n"; break; - case 4: std::cout << "TestID = Left, Upper, NoTrans, NonUnitDiag\n"; break; - } - - // when m == n, lower upper does not matter (unit and nonunit) - double flop = 0; switch (test) { - case 0: + case 0: + SerialTrsm:: + invoke(1.0, aa, bb); + break; case 1: - flop = FlopCountLower(BlkSize,NumCols); + SerialTrsm:: + invoke(1.0, aa, bb); break; case 2: + SerialTrsm:: + invoke(1.0, aa, bb); + break; case 3: + SerialTrsm:: + invoke(1.0, aa, bb); + break; case 4: - flop = FlopCountUpper(BlkSize,NumCols); + SerialTrsm:: + invoke(1.0, aa, bb); break; } - flop *= (N*VectorLength); - const double tmax = 1.0e15; + } + + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV1 &, const MemberType &member) const { + const int kbeg = (member.league_rank()*(member.team_size()*VectorLength) + + member.team_rank()*VectorLength); + Kokkos::parallel_for + (Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_b.extent(0))) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - typedef Kokkos::DefaultHostExecutionSpace HostSpaceType; - typedef typename DeviceSpaceType::memory_space DeviceMemorySpaceType; + switch (test) { + case 0: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 1: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 2: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 3: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 4: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + } + } + }); + } + + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV2 &, const MemberType &member) const { + const int kbeg = member.league_rank()*VectorLength; + Kokkos::parallel_for + (Kokkos::ThreadVectorRange(member, VectorLength), + [&](const int &k) { + const int kk = kbeg + k; + if (kk < int(_b.extent(0))) { + auto aa = Kokkos::subview(_a, kk, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(_b, kk, Kokkos::ALL(), Kokkos::ALL()); - const int iter_begin = -3, iter_end = 30; - Kokkos::Impl::Timer timer; + switch (test) { + case 0: + TeamTrsm:: + invoke(member, 1.0, aa, bb); + break; + case 1: + TeamTrsm:: + invoke(member, 1.0, aa, bb); + break; + case 2: + TeamTrsm:: + invoke(member, 1.0, aa, bb); + break; + case 3: + TeamTrsm:: + invoke(member, 1.0, aa, bb); + break; + case 4: + TeamTrsm:: + invoke(member, 1.0, aa, bb); + break; + } + } + }); + } - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize), - bmat("bmat", N*VectorLength, BlkSize, NumCols), - bref("bmat", N*VectorLength, BlkSize, NumCols); + template + KOKKOS_INLINE_FUNCTION + void operator()(const TeamTagV3 &, const MemberType &member) const { + const int lvl = 0; + ScratchViewType sa(member.team_scratch(lvl), VectorLength, _a.extent(1), _a.extent(2)); + //ScratchViewType sb(member.team_scratch(lvl), VectorLength, _b.extent(1), _b.extent(2)); - { - Random random; - for (int k=0;k::invoke(member, aa, saa); + member.team_barrier(); + + switch (test) { + case 0: + TeamTrsm:: + invoke(member, 1.0, saa, bb); + break; + case 1: + TeamTrsm:: + invoke(member, 1.0, saa, bb); + break; + case 2: + TeamTrsm:: + invoke(member, 1.0, saa, bb); + break; + case 3: + TeamTrsm:: + invoke(member, 1.0, saa, bb); + break; + case 4: + TeamTrsm:: + invoke(member, 1.0, saa, bb); + break; + } + } + }); + } + + }; + + + template + void Trsm(const int NN, const int BlkSize, const int NumCols) { + typedef Kokkos::Schedule ScheduleType; + + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; + + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; + + std::cout << "SIMD is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + } + + switch (test) { + case 0: std::cout << "TestID = Left, Lower, NoTrans, UnitDiag\n"; break; + case 1: std::cout << "TestID = Left, Lower, NoTrans, NonUnitDiag\n"; break; + case 2: std::cout << "TestID = Right, Upper, NoTrans, UnitDiag\n"; break; + case 3: std::cout << "TestID = Right, Upper, NoTrans, NonUnitDiag\n"; break; + case 4: std::cout << "TestID = Left, Upper, NoTrans, NonUnitDiag\n"; break; + } + + // when m == n, lower upper does not matter (unit and nonunit) + double flop = 0; + switch (test) { + case 0: + case 1: + flop = FlopCountLower(BlkSize,NumCols); + break; + case 2: + case 3: + case 4: + flop = FlopCountUpper(BlkSize,NumCols); + break; + } + flop *= (N*VectorLength); + const double tmax = 1.0e15; + + typedef Kokkos::DefaultHostExecutionSpace HostSpaceType; + typedef typename DeviceSpaceType::memory_space DeviceMemorySpaceType; + + const int iter_begin = -3, iter_end = 30; + Kokkos::Impl::Timer timer; + + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize), + bmat("bmat", N*VectorLength, BlkSize, NumCols), + bref("bmat", N*VectorLength, BlkSize, NumCols); + + { + Random random; + for (int k=0;k flush; + // P100 L2 cache 4MB per core + constexpr size_t LLC_CAPACITY = 56*4*1024*1024; + Flush flush; #if defined(__KOKKOSKERNELS_NVIDIA_CUBLAS__) - if (1) { - /// - /// CUBLAS Batch version - /// - const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, - BlkSize, 1, - BlkSize, BlkSize); + if (1) { + /// + /// CUBLAS Batch version + /// + const Kokkos::LayoutStride stride(N*VectorLength, BlkSize*BlkSize, + BlkSize, 1, + BlkSize, BlkSize); - Kokkos::View - a("a", stride), - b("b", stride); + Kokkos::View + a("a", stride), + b("b", stride); - cublasStatus_t stat; - cublasHandle_t handle; + cublasStatus_t stat; + cublasHandle_t handle; - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - Kokkos::abort("CUBLAS initialization failed\n"); + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) + Kokkos::abort("CUBLAS initialization failed\n"); - auto amat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), amat); - auto bmat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), bmat); + auto amat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), amat); + auto bmat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), bmat); - Kokkos::deep_copy(amat_device, amat); - Kokkos::deep_copy(bmat_device, bmat); + Kokkos::deep_copy(amat_device, amat); + Kokkos::deep_copy(bmat_device, bmat); + DeviceSpaceType::fence(); + + const double one(1.0); //, zero(0.0); + { + double tavg = 0, tmin = tmax; + value_type + *aa[N*VectorLength], + *bb[N*VectorLength]; + for (int k=0;k= 0)*t; + if (stat != CUBLAS_STATUS_SUCCESS) { + Kokkos::abort("CUBLAS Trsm Batched failed\n"); } - tavg /= iter_end; + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); - Kokkos::deep_copy(bsol, b); - Kokkos::deep_copy(bref, bsol); + auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); + Kokkos::deep_copy(bsol, b); + Kokkos::deep_copy(bref, bsol); - if (cudaFree(aa_device) != cudaSuccess || - cudaFree(bb_device) != cudaSuccess) { - Kokkos::abort("CUDA memory free failed\n"); - } - - std::cout << std::setw(8) << "CUBLAS" - << std::setw(8) << "Batched" - << " BlkSize = " << std::setw(3) << BlkSize - << " NumCols = " << std::setw(3) << NumCols - << " TeamSize = N/A" - << " ScratchSize (KB) = N/A" - << " time = " << std::scientific << tmin - << " avg flop/s = " << (flop/tavg) - << " max flop/s = " << (flop/tmin) - << std::endl; + if (cudaFree(aa_device) != cudaSuccess || + cudaFree(bb_device) != cudaSuccess) { + Kokkos::abort("CUDA memory free failed\n"); } - cublasDestroy(handle); + + std::cout << std::setw(8) << "CUBLAS" + << std::setw(8) << "Batched" + << " BlkSize = " << std::setw(3) << BlkSize + << " NumCols = " << std::setw(3) << NumCols + << " TeamSize = N/A" + << " ScratchSize (KB) = N/A" + << " time = " << std::scientific << tmin + << " avg flop/s = " << (flop/tavg) + << " max flop/s = " << (flop/tmin) + << std::endl; } + cublasDestroy(handle); + } #endif - if (1) { - /// - /// Range policy version - /// - typedef Kokkos::View view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, NumCols); + if (1) { + /// + /// Range policy version + /// + typedef Kokkos::View view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, NumCols); - double tavg = 0, tmin = tmax; - { - typedef Functor functor_type; - const Kokkos::RangePolicy policy(0, N*VectorLength); + double tavg = 0, tmin = tmax; + { + typedef Functor functor_type; + const Kokkos::RangePolicy policy(0, N*VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); - Kokkos::deep_copy(bsol, b); + auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); + Kokkos::deep_copy(bsol, b); - double diff = 0; - for (int i=0,iend=bref.extent(0);i view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, NumCols); - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; - const int team_size = - policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); + const int team_size = + policy_type(N/32, Kokkos::AUTO, VectorLength).team_size_recommended(functor_type(), Kokkos::ParallelForTag()); - const policy_type policy(N/team_size, team_size, VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; + DeviceSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; + } + tavg /= iter_end; - auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); - Kokkos::deep_copy(bsol, b); + auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); + Kokkos::deep_copy(bsol, b); - double diff = 0; - for (int i=0,iend=bref.extent(0);i policy_type; + typedef Functor functor_type; + + const int + is_blocked_algo = (std::is_same::value), + mb = Algo::Trsm::Blocked::mb(), + mp = BlkSize%mb > 0; + + const int + mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; + + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + const int team_size = std::min(std::max(NumCols,(mblk-1)*mblk), max_team_size); + + const policy_type policy(N, team_size, VectorLength); + for (int iter=iter_begin;iter= 0)*t; } + tavg /= iter_end; + + auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); + Kokkos::deep_copy(bsol, b); + + double diff = 0; + for (int i=0,iend=bref.extent(0);i view_type; + view_type + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, NumCols); - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; + double tavg = 0, tmin = tmax; + { + typedef Kokkos::TeamPolicy policy_type; + typedef Functor functor_type; + + const int lvl = 0, per_team_scratch + = ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); + if (per_team_scratch/1024 < 48) { const int is_blocked_algo = (std::is_same::value), mb = Algo::Trsm::Blocked::mb(), mp = BlkSize%mb > 0; - + const int mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).team_size_max(functor_type(), Kokkos::ParallelForTag()); + const int max_team_size = + policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) + .team_size_max(functor_type(), Kokkos::ParallelForTag()); const int team_size = std::min(std::max(NumCols,(mblk-1)*mblk), max_team_size); - const policy_type policy(N, team_size, VectorLength); + policy_type policy(N, team_size, VectorLength); for (int iter=iter_begin;iter view_type; - view_type - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, NumCols); - - double tavg = 0, tmin = tmax; - { - typedef Kokkos::TeamPolicy policy_type; - typedef Functor functor_type; - - const int lvl = 0, per_team_scratch - = ScratchViewType::shmem_size(VectorLength, BlkSize, BlkSize); - - if (per_team_scratch/1024 < 48) { - const int - is_blocked_algo = (std::is_same::value), - mb = Algo::Trsm::Blocked::mb(), - mp = BlkSize%mb > 0; - - const int - mblk = is_blocked_algo ? (BlkSize/mb + mp) : BlkSize; - - const int max_team_size = - policy_type(N, Kokkos::AUTO, VectorLength).set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)) - .team_size_max(functor_type(), Kokkos::ParallelForTag()); - const int team_size = std::min(std::max(NumCols,(mblk-1)*mblk), max_team_size); - - policy_type policy(N, team_size, VectorLength); - for (int iter=iter_begin;iter= 0)*t; - } - tavg /= iter_end; - - auto bsol = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), b); - Kokkos::deep_copy(bsol, b); - - double diff = 0; - for (int i=0,iend=bref.extent(0);i void run(const int N, const int B, const int R) { diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp b/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp index c345ae1ed8..6df2391b00 100644 --- a/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp @@ -18,345 +18,474 @@ //#undef __KOKKOSBATCHED_INTEL_MKL_BATCHED__ namespace KokkosBatched { - namespace Experimental { - namespace PerfTest { + namespace PerfTest { #undef FLOP_MUL #undef FLOP_ADD - // no complex yet + // no complex yet #if defined( KokkosBatched_Test_Trsm_Host_Complex ) #define FLOP_MUL 6.0 #define FLOP_ADD 2.0 - typedef Kokkos::complex value_type; + typedef Kokkos::complex value_type; #endif #if defined( KokkosBatched_Test_Trsm_Host_Real ) #define FLOP_MUL 1.0 #define FLOP_ADD 1.0 - typedef double value_type; + typedef double value_type; #endif - double FlopCountLower(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - return (FLOP_MUL*(0.5*m*n*(n+1.0)) + - FLOP_ADD*(0.5*m*n*(n-1.0))); - } + double FlopCountLower(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + return (FLOP_MUL*(0.5*m*n*(n+1.0)) + + FLOP_ADD*(0.5*m*n*(n-1.0))); + } - double FlopCountUpper(int mm, int nn) { - double m = (double)mm; double n = (double)nn; - return (FLOP_MUL*(0.5*m*n*(n+1.0)) + - FLOP_ADD*(0.5*m*n*(n-1.0))); - } + double FlopCountUpper(int mm, int nn) { + double m = (double)mm; double n = (double)nn; + return (FLOP_MUL*(0.5*m*n*(n+1.0)) + + FLOP_ADD*(0.5*m*n*(n-1.0))); + } - template - void Trsm(const int NN) { - typedef Kokkos::Schedule ScheduleType; + template + void Trsm(const int NN) { + typedef Kokkos::Schedule ScheduleType; - constexpr int VectorLength = DefaultVectorLength::value; - const int N = NN/VectorLength; + constexpr int VectorLength = DefaultVectorLength::value; + const int N = NN/VectorLength; - { - std::string value_type_name; - if (std::is_same::value) value_type_name = "double"; - if (std::is_same >::value) value_type_name = "Kokkos::complex"; + { + std::string value_type_name; + if (std::is_same::value) value_type_name = "double"; + if (std::is_same >::value) value_type_name = "Kokkos::complex"; #if defined(__AVX512F__) - std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX512 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #elif defined(__AVX__) || defined(__AVX2__) - std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "AVX or AVX2 is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #else - std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; + std::cout << "SIMD (compiler vectorization) is defined: datatype " << value_type_name << " a vector length " << VectorLength << "\n"; #endif - } + } - switch (test) { - case 0: std::cout << "TestID = Left, Lower, NoTrans, UnitDiag\n"; break; - case 1: std::cout << "TestID = Left, Lower, NoTrans, NonUnitDiag\n"; break; - case 2: std::cout << "TestID = Right, Upper, NoTrans, UnitDiag\n"; break; - case 3: std::cout << "TestID = Right, Upper, NoTrans, NonUnitDiag\n"; break; - case 4: std::cout << "TestID = Left, Upper, NoTrans, NonUnitDiag\n"; break; - } + switch (test) { + case 0: std::cout << "TestID = Left, Lower, NoTrans, UnitDiag\n"; break; + case 1: std::cout << "TestID = Left, Lower, NoTrans, NonUnitDiag\n"; break; + case 2: std::cout << "TestID = Right, Upper, NoTrans, UnitDiag\n"; break; + case 3: std::cout << "TestID = Right, Upper, NoTrans, NonUnitDiag\n"; break; + case 4: std::cout << "TestID = Left, Upper, NoTrans, NonUnitDiag\n"; break; + } - // when m == n, lower upper does not matter (unit and nonunit) - double flop = 0; - switch (test) { - case 0: - case 1: - flop = FlopCountLower(BlkSize,NumCols); - break; - case 2: - case 3: - case 4: - flop = FlopCountUpper(BlkSize,NumCols); - break; - } - flop *= (N*VectorLength); + // when m == n, lower upper does not matter (unit and nonunit) + double flop = 0; + switch (test) { + case 0: + case 1: + flop = FlopCountLower(BlkSize,NumCols); + break; + case 2: + case 3: + case 4: + flop = FlopCountUpper(BlkSize,NumCols); + break; + } + flop *= (N*VectorLength); - const double tmax = 1.0e15; + const double tmax = 1.0e15; - const int iter_begin = -10, iter_end = 100; - Kokkos::Impl::Timer timer; + const int iter_begin = -10, iter_end = 100; + Kokkos::Impl::Timer timer; - /// - /// Reference version using MKL DTRSM - /// - Kokkos::View bref; - Kokkos::View - amat("amat", N*VectorLength, BlkSize, BlkSize), - bmat("bmat", N*VectorLength, BlkSize, NumCols); + /// + /// Reference version using MKL DTRSM + /// + Kokkos::View bref; + Kokkos::View + amat("amat", N*VectorLength, BlkSize, BlkSize), + bmat("bmat", N*VectorLength, BlkSize, NumCols); - typedef Vector,VectorLength> VectorType; - Kokkos::View - amat_simd("amat_simd", N, BlkSize, BlkSize), - bmat_simd("bmat_simd", N, BlkSize, NumCols); + typedef Vector,VectorLength> VectorType; + Kokkos::View + amat_simd("amat_simd", N, BlkSize, BlkSize), + bmat_simd("bmat_simd", N, BlkSize, NumCols); - Random random; - - for (int k=0;k random; + + for (int k=0;k flush; + // for KNL + constexpr size_t LLC_CAPACITY = 34*1024*1024; + Flush flush; - /// - /// Reference version using MKL DTRSM - /// + /// + /// Reference version using MKL DTRSM + /// #if defined(__KOKKOSBATCHED_INTEL_MKL__) - { - Kokkos::View - a("a", N*VectorLength, BlkSize, BlkSize), - b("b", N*VectorLength, BlkSize, NumCols); - - { - double tavg = 0, tmin = tmax; - for (int iter=iter_begin;iter policy(0, N*VectorLength); - Kokkos::parallel_for("KokkosBatched::PerfTest::TrsmHost::MKLOpenMP", policy, - KOKKOS_LAMBDA(const int k) { - auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(b, k, Kokkos::ALL(), Kokkos::ALL()); - - switch (test) { - case 0: - cblas_dtrsm(CblasRowMajor, - CblasLeft, CblasLower, CblasNoTrans, CblasUnit, - BlkSize, NumCols, - 1.0, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0()); - break; - case 1: - cblas_dtrsm(CblasRowMajor, - CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, - BlkSize, NumCols, - 1.0, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0()); - break; - case 2: - cblas_dtrsm(CblasRowMajor, - CblasRight, CblasUpper, CblasNoTrans, CblasUnit, - BlkSize, NumCols, - 1.0, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0()); - break; - case 3: - cblas_dtrsm(CblasRowMajor, - CblasRight, CblasUpper, CblasNoTrans, CblasNonUnit, - BlkSize, NumCols, - 1.0, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0()); - break; - case 4: - cblas_dtrsm(CblasRowMajor, - CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, - BlkSize, NumCols, - 1.0, - (double*)aa.data(), aa.stride_0(), - (double*)bb.data(), bb.stride_0()); - break; - } - }); - - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; - - double sum = 0; - for (int i=0,iend=b.extent(0);i policy(0, N*VectorLength); + Kokkos::parallel_for("KokkosBatched::PerfTest::TrsmHost::MKLOpenMP", policy, + KOKKOS_LAMBDA(const int k) { + auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); + auto bb = Kokkos::subview(b, k, Kokkos::ALL(), Kokkos::ALL()); + + switch (test) { + case 0: + cblas_dtrsm(CblasRowMajor, + CblasLeft, CblasLower, CblasNoTrans, CblasUnit, + BlkSize, NumCols, + 1.0, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0()); + break; + case 1: + cblas_dtrsm(CblasRowMajor, + CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, + BlkSize, NumCols, + 1.0, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0()); + break; + case 2: + cblas_dtrsm(CblasRowMajor, + CblasRight, CblasUpper, CblasNoTrans, CblasUnit, + BlkSize, NumCols, + 1.0, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0()); + break; + case 3: + cblas_dtrsm(CblasRowMajor, + CblasRight, CblasUpper, CblasNoTrans, CblasNonUnit, + BlkSize, NumCols, + 1.0, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0()); + break; + case 4: + cblas_dtrsm(CblasRowMajor, + CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, + BlkSize, NumCols, + 1.0, + (double*)aa.data(), aa.stride_0(), + (double*)bb.data(), bb.stride_0()); + break; + } + }); + + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; } + tavg /= iter_end; + + double sum = 0; + for (int i=0,iend=b.extent(0);i + a("a", N*VectorLength, BlkSize, BlkSize), + b("b", N*VectorLength, BlkSize, NumCols); - value_type - *aa[N*VectorLength], - *bb[N*VectorLength]; + value_type + *aa[N*VectorLength], + *bb[N*VectorLength]; - for (int k=0;k= 0)*t; + } + tavg /= iter_end; + + double diff = 0; + for (int i=0,iend=bref.extent(0);i= 0)*t; } tavg /= iter_end; - + double diff = 0; for (int i=0,iend=bref.extent(0);i= 0)*t; - } - tavg /= iter_end; - - double diff = 0; - for (int i=0,iend=bref.extent(0);i policy(0, N*VectorLength); + // Kokkos::parallel_for + // (policy, + // KOKKOS_LAMBDA(const int k) { + // auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); + // auto bb = Kokkos::subview(b, k, Kokkos::ALL(), Kokkos::ALL()); + + // switch (test) { + // case 0: + // SerialTrsm:: + // invoke(1.0, aa, bb); + // break; + // case 1: + // SerialTrsm:: + // invoke(1.0, aa, bb); + // break; + // case 2: + // SerialTrsm:: + // invoke(1.0, aa, bb); + // break; + // case 3: + // SerialTrsm:: + // invoke(1.0, aa, bb); + // break; + // case 4: + // SerialTrsm:: + // invoke(1.0, aa, bb); + // break; + // } + // }); + + // HostSpaceType::fence(); + // const double t = timer.seconds(); + // tmin = std::min(tmin, t); + // tavg += (iter >= 0)*t; + // } + // tavg /= iter_end; + + // double diff = 0; + // for (int i=0,iend=bref.extent(0);i - // a("a", N*VectorLength, BlkSize, BlkSize), - // b("b", N*VectorLength, BlkSize, NumCols); - - // { - // double tavg = 0, tmin = tmax; - // for (int iter=iter_begin;iter policy(0, N*VectorLength); - // Kokkos::parallel_for - // (policy, - // KOKKOS_LAMBDA(const int k) { - // auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - // auto bb = Kokkos::subview(b, k, Kokkos::ALL(), Kokkos::ALL()); - - // switch (test) { - // case 0: - // SerialTrsm:: - // invoke(1.0, aa, bb); - // break; - // case 1: - // SerialTrsm:: - // invoke(1.0, aa, bb); - // break; - // case 2: - // SerialTrsm:: - // invoke(1.0, aa, bb); - // break; - // case 3: - // SerialTrsm:: - // invoke(1.0, aa, bb); - // break; - // case 4: - // SerialTrsm:: - // invoke(1.0, aa, bb); - // break; - // } - // }); - - // HostSpaceType::fence(); - // const double t = timer.seconds(); - // tmin = std::min(tmin, t); - // tavg += (iter >= 0)*t; - // } - // tavg /= iter_end; - - // double diff = 0; - // for (int i=0,iend=bref.extent(0);i policy(0, N); - Kokkos::parallel_for("KokkosBatched::PerfTest::TrsmHost::SIMDSerialOpenMP", - policy, - KOKKOS_LAMBDA(const int k) { - auto aa = Kokkos::subview(a, k, Kokkos::ALL(), Kokkos::ALL()); - auto bb = Kokkos::subview(b, k, Kokkos::ALL(), Kokkos::ALL()); - - switch (test) { - case 0: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 1: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 2: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 3: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - case 4: - SerialTrsm:: - invoke(1.0, aa, bb); - break; - } - }); - - HostSpaceType::fence(); - const double t = timer.seconds(); - tmin = std::min(tmin, t); - tavg += (iter >= 0)*t; - } - tavg /= iter_end; - - double diff = 0; - for (int i=0,iend=bref.extent(0);i:: + invoke(1.0, aa, bb); + break; + case 1: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 2: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 3: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + case 4: + SerialTrsm:: + invoke(1.0, aa, bb); + break; + } + }); + + HostSpaceType::fence(); + const double t = timer.seconds(); + tmin = std::min(tmin, t); + tavg += (iter >= 0)*t; } + tavg /= iter_end; + + double diff = 0; + for (int i=0,iend=bref.extent(0);i void run(const int N) { diff --git a/test_common/KokkosBatched_Test_BlockCrs.hpp b/test_common/KokkosBatched_Test_BlockCrs.hpp index 3bc5e023f8..a40474d375 100644 --- a/test_common/KokkosBatched_Test_BlockCrs.hpp +++ b/test_common/KokkosBatched_Test_BlockCrs.hpp @@ -47,7 +47,6 @@ #include "KokkosBatched_Test_BlockCrs_Util.hpp" namespace KokkosBatched { - using namespace Experimental; namespace Test { struct RangeTag {}; diff --git a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp index d42ca6506c..e172fa98f9 100644 --- a/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp +++ b/unit_test/batched/Test_Batched_SerialEigendecomposition.hpp @@ -11,7 +11,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialGemm.hpp b/unit_test/batched/Test_Batched_SerialGemm.hpp index f4ddb9be47..791c22d054 100644 --- a/unit_test/batched/Test_Batched_SerialGemm.hpp +++ b/unit_test/batched/Test_Batched_SerialGemm.hpp @@ -11,7 +11,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { @@ -143,17 +143,17 @@ int test_batched_gemm() { for (int i=0;i<10;++i) { //printf("Testing: LayoutLeft, Blksize %d\n", i); int dimM=i; int dimN=2*i; int dimK=3*i; - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimN, dimK, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimN, dimK, dimM, dimN); } } } @@ -169,17 +169,17 @@ int test_batched_gemm() { for (int i=0;i<10;++i) { //printf("Testing: LayoutLeft, Blksize %d\n", i); int dimM=i; int dimN=2*i; int dimK=3*i; - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimN, dimK, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimN, dimK, dimM, dimN); } } } diff --git a/unit_test/batched/Test_Batched_SerialGemv.hpp b/unit_test/batched/Test_Batched_SerialGemv.hpp index d03461c4ab..8ed952309b 100644 --- a/unit_test/batched/Test_Batched_SerialGemv.hpp +++ b/unit_test/batched/Test_Batched_SerialGemv.hpp @@ -11,7 +11,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialInverseLU.hpp b/unit_test/batched/Test_Batched_SerialInverseLU.hpp index d8614405b8..3381587017 100644 --- a/unit_test/batched/Test_Batched_SerialInverseLU.hpp +++ b/unit_test/batched/Test_Batched_SerialInverseLU.hpp @@ -15,7 +15,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialLU.hpp b/unit_test/batched/Test_Batched_SerialLU.hpp index b7b2e8665c..27c88fa31b 100644 --- a/unit_test/batched/Test_Batched_SerialLU.hpp +++ b/unit_test/batched/Test_Batched_SerialLU.hpp @@ -11,7 +11,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialMatUtil.hpp b/unit_test/batched/Test_Batched_SerialMatUtil.hpp index d7de734ddc..66fdb14d71 100644 --- a/unit_test/batched/Test_Batched_SerialMatUtil.hpp +++ b/unit_test/batched/Test_Batched_SerialMatUtil.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialSolveLU.hpp b/unit_test/batched/Test_Batched_SerialSolveLU.hpp index 5d4f74db5b..faf23415ec 100644 --- a/unit_test/batched/Test_Batched_SerialSolveLU.hpp +++ b/unit_test/batched/Test_Batched_SerialSolveLU.hpp @@ -15,7 +15,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialTrsm.hpp b/unit_test/batched/Test_Batched_SerialTrsm.hpp index bd2cf660c7..cadbe8a2b3 100644 --- a/unit_test/batched/Test_Batched_SerialTrsm.hpp +++ b/unit_test/batched/Test_Batched_SerialTrsm.hpp @@ -11,7 +11,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_SerialTrsv.hpp b/unit_test/batched/Test_Batched_SerialTrsv.hpp index 9ee0e6c294..c3620e7d9a 100644 --- a/unit_test/batched/Test_Batched_SerialTrsv.hpp +++ b/unit_test/batched/Test_Batched_SerialTrsv.hpp @@ -11,7 +11,7 @@ //#include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamGemm.hpp b/unit_test/batched/Test_Batched_TeamGemm.hpp index b1dba62565..7418361809 100644 --- a/unit_test/batched/Test_Batched_TeamGemm.hpp +++ b/unit_test/batched/Test_Batched_TeamGemm.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { @@ -149,17 +149,17 @@ int test_batched_gemm() { for (int i=0;i<10;++i) { //printf("Testing: LayoutLeft, Blksize %d\n", i); int dimM=i; int dimN=2*i; int dimK=3*i; - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimN, dimK, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimN, dimK, dimM, dimN); } } } @@ -175,17 +175,17 @@ int test_batched_gemm() { for (int i=0;i<10;++i) { //printf("Testing: LayoutLeft, Blksize %d\n", i); int dimM=i; int dimN=2*i; int dimK=3*i; - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimM, dimK, dimN, dimK, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimK, dimN, dimM, dimN); } - if ((std::is_same::value) && - (std::is_same::value)) { + if ((std::is_same::value) && + (std::is_same::value)) { Test::impl_test_batched_gemm(1024, dimK, dimM, dimN, dimK, dimM, dimN); } } } diff --git a/unit_test/batched/Test_Batched_TeamGemv.hpp b/unit_test/batched/Test_Batched_TeamGemv.hpp index 97b45bd3f2..b177411d41 100644 --- a/unit_test/batched/Test_Batched_TeamGemv.hpp +++ b/unit_test/batched/Test_Batched_TeamGemv.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamInverseLU.hpp b/unit_test/batched/Test_Batched_TeamInverseLU.hpp index 430b6623cf..f518ee0110 100644 --- a/unit_test/batched/Test_Batched_TeamInverseLU.hpp +++ b/unit_test/batched/Test_Batched_TeamInverseLU.hpp @@ -15,7 +15,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamLU.hpp b/unit_test/batched/Test_Batched_TeamLU.hpp index 53bdf56b89..c4c1bfa9ae 100644 --- a/unit_test/batched/Test_Batched_TeamLU.hpp +++ b/unit_test/batched/Test_Batched_TeamLU.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamMatUtil.hpp b/unit_test/batched/Test_Batched_TeamMatUtil.hpp index 2fd5461573..aa83082ebb 100644 --- a/unit_test/batched/Test_Batched_TeamMatUtil.hpp +++ b/unit_test/batched/Test_Batched_TeamMatUtil.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamSolveLU.hpp b/unit_test/batched/Test_Batched_TeamSolveLU.hpp index e862f2f057..574b476cd8 100644 --- a/unit_test/batched/Test_Batched_TeamSolveLU.hpp +++ b/unit_test/batched/Test_Batched_TeamSolveLU.hpp @@ -15,7 +15,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamTrsm.hpp b/unit_test/batched/Test_Batched_TeamTrsm.hpp index 8bca273d44..9041cce9ec 100644 --- a/unit_test/batched/Test_Batched_TeamTrsm.hpp +++ b/unit_test/batched/Test_Batched_TeamTrsm.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_TeamTrsv.hpp b/unit_test/batched/Test_Batched_TeamTrsv.hpp index f1fd84a141..eeff89f1c2 100644 --- a/unit_test/batched/Test_Batched_TeamTrsv.hpp +++ b/unit_test/batched/Test_Batched_TeamTrsv.hpp @@ -12,7 +12,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorArithmatic.hpp b/unit_test/batched/Test_Batched_VectorArithmatic.hpp index cba43da73f..a87d6485a5 100644 --- a/unit_test/batched/Test_Batched_VectorArithmatic.hpp +++ b/unit_test/batched/Test_Batched_VectorArithmatic.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorLogical.hpp b/unit_test/batched/Test_Batched_VectorLogical.hpp index d218939dac..1506247813 100644 --- a/unit_test/batched/Test_Batched_VectorLogical.hpp +++ b/unit_test/batched/Test_Batched_VectorLogical.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorMath.hpp b/unit_test/batched/Test_Batched_VectorMath.hpp index 0cdb25f634..82c325596e 100644 --- a/unit_test/batched/Test_Batched_VectorMath.hpp +++ b/unit_test/batched/Test_Batched_VectorMath.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorMisc.hpp b/unit_test/batched/Test_Batched_VectorMisc.hpp index 6942be94b1..8c5f5ea1a2 100644 --- a/unit_test/batched/Test_Batched_VectorMisc.hpp +++ b/unit_test/batched/Test_Batched_VectorMisc.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorRelation.hpp b/unit_test/batched/Test_Batched_VectorRelation.hpp index e76f50bd5f..0cc19a62af 100644 --- a/unit_test/batched/Test_Batched_VectorRelation.hpp +++ b/unit_test/batched/Test_Batched_VectorRelation.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { diff --git a/unit_test/batched/Test_Batched_VectorView.hpp b/unit_test/batched/Test_Batched_VectorView.hpp index 917e01b41c..ad8a70ee29 100644 --- a/unit_test/batched/Test_Batched_VectorView.hpp +++ b/unit_test/batched/Test_Batched_VectorView.hpp @@ -8,7 +8,7 @@ #include "KokkosKernels_TestUtils.hpp" -using namespace KokkosBatched::Experimental; +using namespace KokkosBatched; namespace Test { From b0707ca0dc9d283a0f394afa0f7f38cee5827e66 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Mon, 8 Apr 2019 13:10:38 -0600 Subject: [PATCH 160/190] Replace these files for using KokkoBlas namespace --- src/dense/KokkosDense_gesv.hpp | 129 --------- src/dense/impl/KokkosDense_gesv_impl.hpp | 61 ----- src/dense/impl/KokkosDense_gesv_spec.hpp | 156 ----------- .../tpls/KokkosDense_gesv_tpl_spec_avail.hpp | 107 -------- .../tpls/KokkosDense_gesv_tpl_spec_decl.hpp | 258 ------------------ 5 files changed, 711 deletions(-) delete mode 100644 src/dense/KokkosDense_gesv.hpp delete mode 100644 src/dense/impl/KokkosDense_gesv_impl.hpp delete mode 100644 src/dense/impl/KokkosDense_gesv_spec.hpp delete mode 100644 src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp delete mode 100644 src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp diff --git a/src/dense/KokkosDense_gesv.hpp b/src/dense/KokkosDense_gesv.hpp deleted file mode 100644 index ac2332c298..0000000000 --- a/src/dense/KokkosDense_gesv.hpp +++ /dev/null @@ -1,129 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - -/// \file KokkosDense_gesv.hpp -/// \brief Local dense linear solve -/// -/// This file provides KokkosDense::gesv. This function performs a -/// local (no MPI) dense linear solve on a system of linear equations -/// A * X = B where A is a general N-by-N matrix and X and B are N-by-NRHS matrices. - -#ifndef KOKKOSDENSE_GESV_HPP_ -#define KOKKOSDENSE_GESV_HPP_ - -#include - -#include "KokkosDense_gesv_spec.hpp" - -namespace KokkosDense { - -/// \brief Solve the dense linear equation system A*X = B. -/// -/// \tparam AMatrix Input matrix/Output LU, as a 2-D Kokkos::View. -/// \tparam BXMV Input (right-hand side)/Output (solution) (multi)vector, as a 2-D Kokkos::View. -/// -/// \param pivot [in] "Y" (for partial pivoting), or "N" (for no pivoting). -/// \param A [in,out] On entry, the N-by-N matrix to be solved. On exit, the factors L and U from -/// the factorization A = P*L*U; the unit diagonal elements of L are not stored. -/// \param B [in,out] On entry, the right hand side (multi)vector B. On exit, the solution (multi)vector X. -/// -template -void -trsv (const char pivot[], - const AMatrix& A, - const BXMV& B) -{ - - static_assert (Kokkos::Impl::is_view::value, - "KokkosDense::gesv: A must be a Kokkos::View."); - static_assert (Kokkos::Impl::is_view::value, - "KokkosDense::gesv: B must be a Kokkos::View."); - static_assert (static_cast (AMatrix::rank) == 2, - "KokkosDense::gesv: A must have rank 2."); - static_assert (static_cast (BXMV::rank) == 1 || static_cast (BXMV::rank) == 2, - "KokkosDense::gesv: B must have either rank 1 or rank 2."); - - - // Check validity of pivot argument - bool valid_pivot = (pivot[0] == 'Y') || (pivot[0] == 'y') || - (pivot[0] == 'N') || (pivot[0] == 'n'); - if(!(valid_pivot)) { - std::ostringstream os; - os << "KokkosDense::gesv: pivot[0] = '" << pivot[0] << "'. " << - "Valid values include 'N' or 'n' (No pivoting), 'Y' or 'y' (partial pivoting)."; - Kokkos::Impl::throw_runtime_exception (os.str ()); - } - - // Check compatibility of dimensions at run time. - int64_t A0 = A.extent(0); - int64_t A1 = A.extent(1); - int64_t B0 = B.extent(0); - int64_t B1 = B.extent(1); - - if ( (A0 != A1) || - (A1 != B0) ) { - std::ostringstream os; - os << "KokkosDense::gesv: Dimensions of A, and B do not match: " - << " A: " << A.extent(0) << " x " << A.extent(1) - << " B: " << B.extent(0) << " x " << B.extent(1); - Kokkos::Impl::throw_runtime_exception (os.str ()); - } - - typedef Kokkos::View > AMatrix_Internal; - typedef Kokkos::View > BXMV_Internal; - AMatrix_Internal A_i = A; - BXMV_Internal B_i = B; - - KokkosDense::Impl::GESV::gesv (pivot, A_i, B_i); -} - -} // namespace KokkosDense - -#endif // KOKKOSDENSE_TRSV_HPP_ - diff --git a/src/dense/impl/KokkosDense_gesv_impl.hpp b/src/dense/impl/KokkosDense_gesv_impl.hpp deleted file mode 100644 index 0e42211301..0000000000 --- a/src/dense/impl/KokkosDense_gesv_impl.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - -#ifndef KOKKOSDENSE_IMPL_GESV_HPP_ -#define KOKKOSDENSE_IMPL_GESV_HPP_ - -/// \file KokkosDense_gesv_impl.hpp -/// \brief Implementation(s) of dense linear solve. - -#include -#include - -namespace KokkosDense { -namespace Impl { - -//NOTE: Might add the implementation of KokkosDense::gesv later - -} // namespace Impl -} // namespace KokkosDense - -#endif // KOKKOSDENSE_IMPL_GESV_HPP diff --git a/src/dense/impl/KokkosDense_gesv_spec.hpp b/src/dense/impl/KokkosDense_gesv_spec.hpp deleted file mode 100644 index 96ed3d1cbf..0000000000 --- a/src/dense/impl/KokkosDense_gesv_spec.hpp +++ /dev/null @@ -1,156 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ -#ifndef KOKKOSDENSE_IMPL_GESV_SPEC_HPP_ -#define KOKKOSDENSE_IMPL_GESV_SPEC_HPP_ - -#include -#include -#include - -// Include the actual functors -#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY -#include -#endif - -namespace KokkosDense { -namespace Impl { -// Specialization struct which defines whether a specialization exists -template -struct gesv_eti_spec_avail { - enum : bool { value = false }; -}; -} -} - -// -// Macro for declaration of full specialization availability -// KokkosBlas::Impl::GEMM. This is NOT for users!!! All -// the declarations of full specializations go in this header file. -// We may spread out definitions (see _INST macro below) across one or -// more .cpp files. -// -#define KOKKOSDENSE_GESV_ETI_SPEC_AVAIL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ - template<> \ - struct gesv_eti_spec_avail< \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits > > \ - { enum : bool { value = true }; }; - -// Include the actual specialization declarations -#include -#include - -namespace KokkosDense { -namespace Impl { - -// Unification layer -/// \brief Implementation of KokkosDense::gesv. - -template::value, - bool eti_spec_avail = gesv_eti_spec_avail::value - > -struct GESV{ - static void - gesv (const char pivot[], - const AMatrix& A, - BXMV& B); -}; - - -#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY -//! Full specialization of gesv for multi vectors. -// Unification layer -template -struct GESV< AMatrix, BXMV, false, KOKKOSKERNELS_IMPL_COMPILE_LIBRARY>{ - static void - gesv (const char pivot[], - const AMatrix& A, - const BXMV& B) - { - //NOTE: Might add the implementation of KokkosDense::gesv later - } -}; - -#endif -}// namespace Impl -}// namespace KokkosDense - -// -// Macro for declaration of full specialization of -// KokkosDense::Impl::GESV. This is NOT for users!!! All -// the declarations of full specializations go in this header file. -// We may spread out definitions (see _DEF macro below) across one or -// more .cpp files. -// -#define KOKKOSDENSE_GESV_ETI_SPEC_DECL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE ) \ - extern template struct \ - GESV< Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - false, true >; \ - -#define KOKKOSDENSE_TRSV_ETI_SPEC_INST( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ - template struct \ - GESV< Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - false, true > ; - -#include -#include - - -#endif // KOKKOS_BLAS1_MV_IMPL_DOT_HPP_ diff --git a/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp b/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp deleted file mode 100644 index 4cbb8cb715..0000000000 --- a/src/impl/tpls/KokkosDense_gesv_tpl_spec_avail.hpp +++ /dev/null @@ -1,107 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - -#ifndef KOKKODENSE_GESV_TPL_SPEC_AVAIL_HPP_ -#define KOKKODENSE_GESV_TPL_SPEC_AVAIL_HPP_ - -namespace KokkosDense { -namespace Impl { -// Specialization struct which defines whether a specialization exists -template -struct gesv_tpl_spec_avail { - enum : bool { value = false }; -}; - -// MAGMA -#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA - -#define KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( SCALAR, LAYOUT, MEMSPACE ) \ -template \ -struct gesv_tpl_spec_avail< \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - > { enum : bool { value = true }; }; - -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) - KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutLeft, Kokkos::CudaSpace) -#endif -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) - KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutLeft, Kokkos::CudaSpace) -#endif -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) - KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) -#endif -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) - KOKKOSDENSE_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) -#endif - -//#if defined (KOKKOSKERNELS_INST_DOUBLE) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( double, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_FLOAT) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( float, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS3_GEMM_TPL_SPEC_AVAIL_CUBLAS( Kokkos::complex, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif - -#endif - -} -} - -#endif diff --git a/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp b/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp deleted file mode 100644 index ae971453a2..0000000000 --- a/src/impl/tpls/KokkosDense_gesv_tpl_spec_decl.hpp +++ /dev/null @@ -1,258 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - -#ifndef KOKKOSDENSE_GESV_TPL_SPEC_DECL_HPP_ -#define KOKKOSDENSE_GESV_TPL_SPEC_DECL_HPP_ - -// MAGMA -#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA -#include - -namespace KokkosDense { -namespace Impl { - -#define KOKKOSDENSE_DGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ -template \ -struct GESV< \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - true, ETI_SPEC_AVAIL> { \ - typedef double SCALAR; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > AViewType; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > BViewType; \ - \ - static void \ - gesv (const char pivot[], \ - const AViewType& A, \ - const BViewType& B) { \ - \ - Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,double]"); \ - const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ - const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ - \ - magma_int_t N = static_cast (A.extent(1)); \ - magma_int_t LDA = static_cast (A.stride(0)); \ - magma_int_t LDB = static_cast (B.stride(0)); \ - magma_int_t NRHS = static_cast (B.extent(1)); \ - \ - magma_init(); \ - \ - magma_int_t *ipiv = NULL; \ - magma_int_t info = 0; \ - \ - magma_imalloc_cpu( &ipiv, N ); \ - \ - if(pivot_t) \ - magma_dgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ - if(nopivot_t) \ - magma_dgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ - \ - magma_free_cpu( ipiv ); \ - \ - magma_finalize(); \ - Kokkos::Profiling::popRegion(); \ - } \ -}; - -#define KOKKOSDENSE_SGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ -template \ -struct GESV< \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - Kokkos::View, \ - Kokkos::MemoryTraits >, \ - true, ETI_SPEC_AVAIL> { \ - typedef float SCALAR; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > AViewType; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > BViewType; \ - \ - static void \ - gesv (const char pivot[], \ - const AViewType& A, \ - const BViewType& B) { \ - \ - Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,float]"); \ - const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ - const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ - \ - magma_int_t N = static_cast (A.extent(1)); \ - magma_int_t LDA = static_cast (A.stride(0)); \ - magma_int_t LDB = static_cast (B.stride(0)); \ - magma_int_t NRHS = static_cast (B.extent(1)); \ - \ - magma_init(); \ - \ - magma_int_t *ipiv = NULL; \ - magma_int_t info = 0; \ - \ - magma_imalloc_cpu( &ipiv, N ); \ - \ - if(pivot_t) \ - magma_sgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ - if(nopivot_t) \ - magma_sgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ - \ - magma_free_cpu( ipiv ); \ - \ - magma_finalize(); \ - Kokkos::Profiling::popRegion(); \ - } \ -}; - -#define KOKKOSDENSE_ZGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ -template \ -struct GESV< \ - Kokkos::View**, LAYOUT, Kokkos::Device, \ - Kokkos::MemoryTraits >, \ - Kokkos::View**, LAYOUT, Kokkos::Device, \ - Kokkos::MemoryTraits >, \ - true, ETI_SPEC_AVAIL> { \ - typedef Kokkos::complex SCALAR; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > AViewType; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > BViewType; \ - \ - static void \ - gesv (const char pivot[], \ - const AViewType& A, \ - const BViewType& B) { \ - \ - Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,complex]"); \ - const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ - const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ - \ - magma_int_t N = static_cast (A.extent(1)); \ - magma_int_t LDA = static_cast (A.stride(0)); \ - magma_int_t LDB = static_cast (B.stride(0)); \ - magma_int_t NRHS = static_cast (B.extent(1)); \ - \ - magma_init(); \ - \ - magma_int_t *ipiv = NULL; \ - magma_int_t info = 0; \ - \ - magma_imalloc_cpu( &ipiv, N ); \ - \ - if(pivot_t) \ - magma_zgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ - if(nopivot_t) \ - magma_zgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ - \ - magma_free_cpu( ipiv ); \ - \ - magma_finalize(); \ - Kokkos::Profiling::popRegion(); \ - } \ -}; \ - -#define KOKKOSDENSE_CGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ -template \ -struct GESV< \ - Kokkos::View**, LAYOUT, Kokkos::Device, \ - Kokkos::MemoryTraits >, \ - Kokkos::View**, LAYOUT, Kokkos::Device, \ - Kokkos::MemoryTraits >, \ - true, ETI_SPEC_AVAIL> { \ - typedef Kokkos::complex SCALAR; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > AViewType; \ - typedef Kokkos::View, \ - Kokkos::MemoryTraits > BViewType; \ - \ - static void \ - gesv (const char pivot[], \ - const AViewType& A, \ - const BViewType& B) { \ - \ - Kokkos::Profiling::pushRegion("KokkosDense::gesv[TPL_MAGMA,complex]"); \ - const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ - const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ - \ - magma_int_t N = static_cast (A.extent(1)); \ - magma_int_t LDA = static_cast (A.stride(0)); \ - magma_int_t LDB = static_cast (B.stride(0)); \ - magma_int_t NRHS = static_cast (B.extent(1)); \ - \ - magma_init(); \ - \ - magma_int_t *ipiv = NULL; \ - magma_int_t info = 0; \ - \ - magma_imalloc_cpu( &ipiv, N ); \ - \ - if(pivot_t) \ - magma_cgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ - if(nopivot_t) \ - magma_cgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ - \ - magma_free_cpu( ipiv ); \ - \ - magma_finalize(); \ - Kokkos::Profiling::popRegion(); \ - } \ -}; - -KOKKOSDENSE_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) -KOKKOSDENSE_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) - -KOKKOSDENSE_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) -KOKKOSDENSE_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) - -KOKKOSDENSE_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) -KOKKOSDENSE_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) - -KOKKOSDENSE_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) -KOKKOSDENSE_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) - -} -} -#endif // KOKKOSKERNELS_ENABLE_TPL_MAGMA - -#endif From bfba260c9af5c9b6033cddd56de4cb9575738404 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Mon, 8 Apr 2019 13:19:05 -0600 Subject: [PATCH 161/190] Add MAGMA TPL implementation using KokkosBlas namespace --- Makefile.kokkos-kernels | 20 +- src/Makefile | 2 +- src/blas/KokkosBlas_gesv.hpp | 136 +++++ src/blas/impl/KokkosBlas_gesv_impl.hpp | 61 +++ src/blas/impl/KokkosBlas_gesv_spec.hpp | 156 ++++++ .../KokkosBlas_gesv_eti_spec_avail.hpp | 498 ++++++++++++++++++ .../KokkosBlas_gesv_eti_spec_decl.hpp | 498 ++++++++++++++++++ src/impl/tpls/KokkosBlas_Cuda_tpl.cpp | 2 +- src/impl/tpls/KokkosBlas_Cuda_tpl.hpp | 26 +- .../tpls/KokkosBlas_gesv_tpl_spec_avail.hpp | 107 ++++ .../tpls/KokkosBlas_gesv_tpl_spec_decl.hpp | 254 +++++++++ src/impl/tpls/KokkosBlas_tpl_spec.hpp | 18 + unit_test/Makefile | 1 + unit_test/blas/Test_Blas_gesv.hpp | 271 ++++++++++ unit_test/cuda/Test_Cuda_Blas_gesv.cpp | 2 + unit_test/openmp/Test_OpenMP_Blas_gesv.cpp | 2 + unit_test/serial/Test_Serial_Blas_gesv.cpp | 2 + unit_test/threads/Test_Threads_Blas_gesv.cpp | 2 + 18 files changed, 2054 insertions(+), 4 deletions(-) create mode 100644 src/blas/KokkosBlas_gesv.hpp create mode 100644 src/blas/impl/KokkosBlas_gesv_impl.hpp create mode 100644 src/blas/impl/KokkosBlas_gesv_spec.hpp create mode 100644 src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_avail.hpp create mode 100644 src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_decl.hpp create mode 100644 src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp create mode 100644 src/impl/tpls/KokkosBlas_gesv_tpl_spec_decl.hpp create mode 100644 unit_test/blas/Test_Blas_gesv.hpp create mode 100644 unit_test/cuda/Test_Cuda_Blas_gesv.cpp create mode 100644 unit_test/openmp/Test_OpenMP_Blas_gesv.cpp create mode 100644 unit_test/serial/Test_Serial_Blas_gesv.cpp create mode 100644 unit_test/threads/Test_Threads_Blas_gesv.cpp diff --git a/Makefile.kokkos-kernels b/Makefile.kokkos-kernels index 274cd2ef85..6c15670832 100644 --- a/Makefile.kokkos-kernels +++ b/Makefile.kokkos-kernels @@ -12,7 +12,7 @@ KOKKOSKERNELS_SPACES ?= $(KOKKOS_DEVICES),HostSpace KOKKOSKERNELS_ORDINALS ?= int,int64_t KOKKOSKERNELS_OFFSETS ?= int,size_t -# mkl, blas, yaml +# mkl, blas, yaml, magma KOKKOSKERNELS_ENABLE_TPLS ?= "" # eti-only @@ -23,6 +23,7 @@ KOKKOSKERNELS_INTERNAL_ENABLE_BLAS := $(strip $(shell echo $(KOKKOSKERNELS_ENABL KOKKOSKERNELS_INTERNAL_ENABLE_MKL := $(strip $(shell echo $(KOKKOSKERNELS_ENABLE_TPLS) | grep "mkl" | wc -l)) KOKKOSKERNELS_INTERNAL_ENABLE_CUSPARSE := $(strip $(shell echo $(KOKKOSKERNELS_ENABLE_TPLS) | grep "cusparse" | wc -l)) KOKKOSKERNELS_INTERNAL_ENABLE_CUBLAS := $(strip $(shell echo $(KOKKOSKERNELS_ENABLE_TPLS) | grep "cublas" | wc -l)) +KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA := $(strip $(shell echo $(KOKKOSKERNELS_ENABLE_TPLS) | grep "magma" | wc -l)) YAML_PATH ?= ${HOME}/yaml-cpp/install YAML_LIBS ?= -L${YAML_PATH}/lib -lyaml-cpp @@ -33,6 +34,9 @@ BLAS_LIBS ?= -L${BLAS_PATH}/lib64 $(BLAS_LIBRARIES) -lgfortran -lgomp MKL_PATH ?= ${SEMS_INTEL_ROOT}/mkl MKL_LIBS ?= -L${MKL_PATH}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl -L${MKL_PATH}/../compiler/lib/intel64 +MAGMA_PATH ?= ${MAGMADIR} +OPENBLAS_PATH ?= ${OPENBLAS_ROOT} + default-kokkos-kernels: kokkoskernels-build-lib echo "Start Build" @@ -306,6 +310,16 @@ ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_CUBLAS}, 1) tmp := $(shell echo "\#define KOKKOSKERNELS_ENABLE_TPL_CUBLAS" >> KokkosKernels_config.tmp ) endif +ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc) + CUDA_PATH ?= $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=) + KOKKOSKERNELS_CPPFLAGS += -DADD_ -I${MAGMA_PATH}/include -I${MAGMA_PATH}/sparse/include -I${CUDA_PATH}/include + KOKKOSKERNELS_LDFLAGS += -L${MAGMA_PATH}/lib -L${CUDA_PATH}/lib64 -L${OPENBLAS_PATH}/lib + KOKKOSKERNELS_LIBS += -lmagma_sparse -lmagma -lcublas -lcudart -lcusparse -lopenblas -fopenmp + + tmp := $(shell echo "\#define KOKKOSKERNELS_ENABLE_TPL_MAGMA" >> KokkosKernels_config.tmp ) +endif + tmp := $(shell echo "\#if defined(KOKKOSKERNELS_ENABLE_TPL_MKL)" >> KokkosKernels_config.tmp ) tmp := $(shell echo "\#if !defined(KOKKOSKERNELS_ENABLE_TPL_BLAS)" >> KokkosKernels_config.tmp ) tmp := $(shell echo "\#define KOKKOSKERNELS_ENABLE_TPL_BLAS" >> KokkosKernels_config.tmp ) @@ -435,6 +449,10 @@ ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_CUBLAS}, 1) KOKKOSKERNELS_INTERNAL_SRC_BLAS += ${KOKKOSKERNELS_PATH}/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp endif +ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + KOKKOSKERNELS_INTERNAL_SRC_BLAS += ${KOKKOSKERNELS_PATH}/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp +endif + KOKKOSKERNELS_INTERNAL_ENABLE_HOST_BLAS=0 ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_BLAS}, 1) KOKKOSKERNELS_INTERNAL_ENABLE_HOST_BLAS=1 diff --git a/src/Makefile b/src/Makefile index 67070a296a..f8604193b1 100644 --- a/src/Makefile +++ b/src/Makefile @@ -46,7 +46,7 @@ kokkoskernels-install: kokkoskernels-build-lib mkdir -p $(KOKKOSKERNELS_INSTALL_PATH)/lib echo "# KokkosKernels Settings" > $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "KOKKOSKERNELS_PATH = ${KOKKOSKERNELS_INSTALL_PATH}" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels - echo "KOKKOSKERNELS_CPPFLAGS = -I$(KOKKOSKERNELS_INSTALL_PATH)/include" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels + echo "KOKKOSKERNELS_CPPFLAGS = -I$(KOKKOSKERNELS_INSTALL_PATH)/include $(KOKKOSKERNELS_CPPFLAGS)" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "KOKKOSKERNELS_LDFLAGS = -L$(KOKKOSKERNELS_INSTALL_PATH)/lib $(KOKKOSKERNELS_LDFLAGS)" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "KOKKOSKERNELS_LIBS = $(KOKKOSKERNELS_LIBS)" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels echo "KOKKOSKERNELS_LINK_DEPENDS = $(KOKKOSKERNELS_INSTALL_PATH)/lib/$(KOKKOSKERNELS_LINK_DEPENDS)" >> $(KOKKOSKERNELS_INSTALL_PATH)/Makefile.kokkos-kernels diff --git a/src/blas/KokkosBlas_gesv.hpp b/src/blas/KokkosBlas_gesv.hpp new file mode 100644 index 0000000000..f018f1fba8 --- /dev/null +++ b/src/blas/KokkosBlas_gesv.hpp @@ -0,0 +1,136 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +/// \file KokkosBlas_gesv.hpp +/// \brief Local dense linear solve +/// +/// This file provides KokkosBlas::gesv. This function performs a +/// local (no MPI) dense linear solve on a system of linear equations +/// A * X = B where A is a general N-by-N matrix and X and B are N-by-NRHS matrices. + +#ifndef KOKKOSBLAS_GESV_HPP_ +#define KOKKOSBLAS_GESV_HPP_ + +#include + +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { + +/// \brief Solve the dense linear equation system A*X = B. +/// +/// \tparam AMatrix Input matrix/Output LU, as a 2-D Kokkos::View. +/// \tparam BXMV Input (right-hand side)/Output (solution) (multi)vector, as a 2-D Kokkos::View. +/// +/// \param pivot [in] "Y" (for partial pivoting), or "N" (for no pivoting). +/// \param A [in,out] On entry, the N-by-N matrix to be solved. On exit, the factors L and U from +/// the factorization A = P*L*U; the unit diagonal elements of L are not stored. +/// \param B [in,out] On entry, the right hand side (multi)vector B. On exit, the solution (multi)vector X. +/// +template +void +gesv (const char pivot[], + const AMatrix& A, + const BXMV& B) +{ + + static_assert (Kokkos::Impl::is_view::value, + "KokkosBlas::gesv: A must be a Kokkos::View."); + static_assert (Kokkos::Impl::is_view::value, + "KokkosBlas::gesv: B must be a Kokkos::View."); + static_assert (static_cast (AMatrix::rank) == 2, + "KokkosBlas::gesv: A must have rank 2."); + static_assert (static_cast (BXMV::rank) == 1 || static_cast (BXMV::rank) == 2, + "KokkosBlas::gesv: B must have either rank 1 or rank 2."); + + + // Check validity of pivot argument + bool valid_pivot = (pivot[0] == 'Y') || (pivot[0] == 'y') || + (pivot[0] == 'N') || (pivot[0] == 'n'); + if(!(valid_pivot)) { + std::ostringstream os; + os << "KokkosBlas::gesv: pivot[0] = '" << pivot[0] << "'. " << + "Valid values include 'N' or 'n' (No pivoting), 'Y' or 'y' (partial pivoting)."; + Kokkos::Impl::throw_runtime_exception (os.str ()); + } + + // Check compatibility of dimensions at run time. + int64_t A0 = A.extent(0); + int64_t A1 = A.extent(1); + int64_t B0 = B.extent(0); + + if ( (A0 < A1) || + (A0 != B0) ) { + std::ostringstream os; + os << "KokkosBlas::gesv: Dimensions of A, and B do not match: " + << " A: " << A.extent(0) << " x " << A.extent(1) + << " B: " << B.extent(0) << " x " << B.extent(1); + Kokkos::Impl::throw_runtime_exception (os.str ()); + } + + typedef Kokkos::View > AMatrix_Internal; + typedef Kokkos::View > BXMV_Internal; + AMatrix_Internal A_i = A; + //BXMV_Internal B_i = B; + + if (BXMV::rank == 1) { + auto B_i = BXMV_Internal(B.data(), B.extent(0), 1); + KokkosBlas::Impl::GESV::gesv (pivot, A_i, B_i); + } + else { //BXMV::rank == 2 + auto B_i = BXMV_Internal(B.data(), B.extent(0), B.extent(1)); + KokkosBlas::Impl::GESV::gesv (pivot, A_i, B_i); + } + +} + +} // namespace KokkosBlas + +#endif // KOKKOSBLAS_TRSV_HPP_ + diff --git a/src/blas/impl/KokkosBlas_gesv_impl.hpp b/src/blas/impl/KokkosBlas_gesv_impl.hpp new file mode 100644 index 0000000000..0699764df0 --- /dev/null +++ b/src/blas/impl/KokkosBlas_gesv_impl.hpp @@ -0,0 +1,61 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSBLAS_IMPL_GESV_HPP_ +#define KOKKOSBLAS_IMPL_GESV_HPP_ + +/// \file KokkosBlas_gesv_impl.hpp +/// \brief Implementation(s) of dense linear solve. + +#include +#include + +namespace KokkosBlas { +namespace Impl { + +//NOTE: Might add the implementation of KokkosBlas::gesv later + +} // namespace Impl +} // namespace KokkosBlas + +#endif // KOKKOSBLAS_IMPL_GESV_HPP diff --git a/src/blas/impl/KokkosBlas_gesv_spec.hpp b/src/blas/impl/KokkosBlas_gesv_spec.hpp new file mode 100644 index 0000000000..ac8d7803d4 --- /dev/null +++ b/src/blas/impl/KokkosBlas_gesv_spec.hpp @@ -0,0 +1,156 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#ifndef KOKKOSBLAS_IMPL_GESV_SPEC_HPP_ +#define KOKKOSBLAS_IMPL_GESV_SPEC_HPP_ + +#include +#include +#include + +// Include the actual functors +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +#include +#endif + +namespace KokkosBlas { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct gesv_eti_spec_avail { + enum : bool { value = false }; +}; +} +} + +// +// Macro for declaration of full specialization availability +// KokkosBlas::Impl::GESV. This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _INST macro below) across one or +// more .cpp files. +// +#define KOKKOSBLAS_GESV_ETI_SPEC_AVAIL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template<> \ + struct gesv_eti_spec_avail< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits > > \ + { enum : bool { value = true }; }; + +// Include the actual specialization declarations +#include +#include + +namespace KokkosBlas { +namespace Impl { + +// Unification layer +/// \brief Implementation of KokkosBlas::gesv. + +template::value, + bool eti_spec_avail = gesv_eti_spec_avail::value + > +struct GESV{ + static void + gesv (const char pivot[], + AMatrix& A, + BXMV& B); +}; + + +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +//! Full specialization of gesv for multi vectors. +// Unification layer +template +struct GESV< AMatrix, BXMV, false, KOKKOSKERNELS_IMPL_COMPILE_LIBRARY>{ + static void + gesv (const char pivot[], + const AMatrix& A, + const BXMV& B) + { + //NOTE: Might add the implementation of KokkosBlas::gesv later + } +}; + +#endif +}// namespace Impl +}// namespace KokkosBlas + +// +// Macro for declaration of full specialization of +// KokkosBlas::Impl::GESV. This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _DEF macro below) across one or +// more .cpp files. +// +#define KOKKOSBLAS_GESV_ETI_SPEC_DECL( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE ) \ + extern template struct \ + GESV< Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true >; \ + +#define KOKKOSBLAS_TRSV_ETI_SPEC_INST( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template struct \ + GESV< Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true > ; + +#include +#include + + +#endif // KOKKOSBLAS_IMPL_GESV_SPEC_HPP_ diff --git a/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_avail.hpp b/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_avail.hpp new file mode 100644 index 0000000000..15b1a6827f --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_avail.hpp @@ -0,0 +1,498 @@ +#ifndef KOKKOSBLAS_GESV_ETI_SPEC_AVAIL_HPP_ +#define KOKKOSBLAS_GESV_ETI_SPEC_AVAIL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosBlas { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_AVAIL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosBlas +#endif // KOKKOSBLAS_GESV_ETI_SPEC_AVAIL_HPP_ diff --git a/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_decl.hpp b/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_decl.hpp new file mode 100644 index 0000000000..3e2fd968dd --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosBlas_gesv_eti_spec_decl.hpp @@ -0,0 +1,498 @@ +#ifndef KOKKOSBLAS_GESV_ETI_SPEC_DECL_HPP_ +#define KOKKOSBLAS_GESV_ETI_SPEC_DECL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosBlas { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) + KOKKOSBLAS_GESV_ETI_SPEC_DECL(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosBlas +#endif // KOKKOSBLAS_GESV_ETI_SPEC_DECL_HPP_ diff --git a/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp b/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp index 91480f766b..bac6705590 100644 --- a/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp +++ b/src/impl/tpls/KokkosBlas_Cuda_tpl.cpp @@ -1,3 +1,3 @@ #include #include -#include \ No newline at end of file +#include diff --git a/src/impl/tpls/KokkosBlas_Cuda_tpl.hpp b/src/impl/tpls/KokkosBlas_Cuda_tpl.hpp index a6fed196bd..46799b6142 100644 --- a/src/impl/tpls/KokkosBlas_Cuda_tpl.hpp +++ b/src/impl/tpls/KokkosBlas_Cuda_tpl.hpp @@ -1,7 +1,7 @@ #ifndef KOKKOSBLAS_CUDA_TPL_HPP_ #define KOKKOSBLAS_CUDA_TPL_HPP_ -#ifdef KOKKOSKERNELS_ENABLE_TPL_CUBLAS +#if defined (KOKKOSKERNELS_ENABLE_TPL_CUBLAS) #include namespace KokkosBlas { @@ -25,4 +25,28 @@ CudaBlasSingleton & CudaBlasSingleton::singleton() } #endif +#if defined (KOKKOSKERNELS_ENABLE_TPL_MAGMA) +#include + +namespace KokkosBlas { +namespace Impl { + +MagmaSingleton::MagmaSingleton() +{ + magma_int_t stat = magma_init(); + if (stat != MAGMA_SUCCESS) + Kokkos::abort("MAGMA initialization failed\n"); + + Kokkos::push_finalize_hook ([&] () { + magma_finalize(); + }); +} + +MagmaSingleton & MagmaSingleton::singleton() +{ static MagmaSingleton s ; return s ; } + +} +} +#endif + #endif \ No newline at end of file diff --git a/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp new file mode 100644 index 0000000000..fec7b97782 --- /dev/null +++ b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp @@ -0,0 +1,107 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_HPP_ +#define KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_HPP_ + +namespace KokkosBlas { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct gesv_tpl_spec_avail { + enum : bool { value = false }; +}; + +// MAGMA +#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA + +#define KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( SCALAR, LAYOUT, MEMSPACE ) \ +template \ +struct gesv_tpl_spec_avail< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + > { enum : bool { value = true }; }; + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) +#endif + +//#if defined (KOKKOSKERNELS_INST_DOUBLE) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_FLOAT) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex,Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif +//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ +// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) +// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutRight, Kokkos::CudaSpace) +//#endif + +#endif + +} +} + +#endif diff --git a/src/impl/tpls/KokkosBlas_gesv_tpl_spec_decl.hpp b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_decl.hpp new file mode 100644 index 0000000000..781e004640 --- /dev/null +++ b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_decl.hpp @@ -0,0 +1,254 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSBLAS_GESV_TPL_SPEC_DECL_HPP_ +#define KOKKOSBLAS_GESV_TPL_SPEC_DECL_HPP_ + +// MAGMA +#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA +#include + +namespace KokkosBlas { +namespace Impl { + +#define KOKKOSBLAS_DGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef double SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosBlas::gesv[TPL_MAGMA,double]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t AST = static_cast (A.stride(1)); \ + magma_int_t LDA = (AST == 0) ? 1 : AST; \ + magma_int_t BST = static_cast (B.stride(1)); \ + magma_int_t LDB = (BST == 0) ? 1 : BST; \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + KokkosBlas::Impl::MagmaSingleton & s = KokkosBlas::Impl::MagmaSingleton::singleton(); \ + magma_int_t info = 0; \ + \ + if(pivot_t) { \ + magma_int_t *ipiv = NULL; \ + magma_imalloc_cpu( &ipiv, N ); \ + magma_dgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + magma_free_cpu( ipiv ); \ + } \ + if(nopivot_t) \ + magma_dgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +#define KOKKOSBLAS_SGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef float SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosBlas::gesv[TPL_MAGMA,float]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t AST = static_cast (A.stride(1)); \ + magma_int_t LDA = (AST == 0) ? 1 : AST; \ + magma_int_t BST = static_cast (B.stride(1)); \ + magma_int_t LDB = (BST == 0) ? 1 : BST; \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + KokkosBlas::Impl::MagmaSingleton & s = KokkosBlas::Impl::MagmaSingleton::singleton(); \ + magma_int_t info = 0; \ + \ + if(pivot_t) { \ + magma_int_t *ipiv = NULL; \ + magma_imalloc_cpu( &ipiv, N ); \ + magma_sgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + magma_free_cpu( ipiv ); \ + } \ + if(nopivot_t) \ + magma_sgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +#define KOKKOSBLAS_ZGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef Kokkos::complex SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosBlas::gesv[TPL_MAGMA,complex]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t AST = static_cast (A.stride(1)); \ + magma_int_t LDA = (AST == 0) ? 1 : AST; \ + magma_int_t BST = static_cast (B.stride(1)); \ + magma_int_t LDB = (BST == 0) ? 1 : BST; \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + KokkosBlas::Impl::MagmaSingleton & s = KokkosBlas::Impl::MagmaSingleton::singleton(); \ + magma_int_t info = 0; \ + \ + if(pivot_t) { \ + magma_int_t *ipiv = NULL; \ + magma_imalloc_cpu( &ipiv, N ); \ + magma_zgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + magma_free_cpu( ipiv ); \ + } \ + if(nopivot_t) \ + magma_zgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + Kokkos::Profiling::popRegion(); \ + } \ +}; \ + +#define KOKKOSBLAS_CGESV_MAGMA( LAYOUT, MEM_SPACE, ETI_SPEC_AVAIL ) \ +template \ +struct GESV< \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + Kokkos::View**, LAYOUT, Kokkos::Device, \ + Kokkos::MemoryTraits >, \ + true, ETI_SPEC_AVAIL> { \ + typedef Kokkos::complex SCALAR; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > AViewType; \ + typedef Kokkos::View, \ + Kokkos::MemoryTraits > BViewType; \ + \ + static void \ + gesv (const char pivot[], \ + const AViewType& A, \ + const BViewType& B) { \ + \ + Kokkos::Profiling::pushRegion("KokkosBlas::gesv[TPL_MAGMA,complex]"); \ + const bool nopivot_t = (pivot[0]=='N') || (pivot[0]=='n'); \ + const bool pivot_t = (pivot[0]=='Y') || (pivot[0]=='y'); \ + \ + magma_int_t N = static_cast (A.extent(1)); \ + magma_int_t AST = static_cast (A.stride(1)); \ + magma_int_t LDA = (AST == 0) ? 1 : AST; \ + magma_int_t BST = static_cast (B.stride(1)); \ + magma_int_t LDB = (BST == 0) ? 1 : BST; \ + magma_int_t NRHS = static_cast (B.extent(1)); \ + \ + KokkosBlas::Impl::MagmaSingleton & s = KokkosBlas::Impl::MagmaSingleton::singleton(); \ + magma_int_t info = 0; \ + \ + if(pivot_t) { \ + magma_int_t *ipiv = NULL; \ + magma_imalloc_cpu( &ipiv, N ); \ + magma_cgesv_gpu ( N, NRHS, reinterpret_cast(A.data()), LDA, ipiv, reinterpret_cast(B.data()), LDB, &info ); \ + magma_free_cpu( ipiv ); \ + } \ + if(nopivot_t) \ + magma_cgesv_nopiv_gpu( N, NRHS, reinterpret_cast(A.data()), LDA, reinterpret_cast(B.data()), LDB, &info ); \ + \ + Kokkos::Profiling::popRegion(); \ + } \ +}; + +KOKKOSBLAS_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSBLAS_DGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSBLAS_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSBLAS_SGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSBLAS_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSBLAS_ZGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +KOKKOSBLAS_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, true) +KOKKOSBLAS_CGESV_MAGMA( Kokkos::LayoutLeft, Kokkos::CudaSpace, false) + +} +} +#endif // KOKKOSKERNELS_ENABLE_TPL_MAGMA + +#endif diff --git a/src/impl/tpls/KokkosBlas_tpl_spec.hpp b/src/impl/tpls/KokkosBlas_tpl_spec.hpp index 674867d92c..7b1c681929 100644 --- a/src/impl/tpls/KokkosBlas_tpl_spec.hpp +++ b/src/impl/tpls/KokkosBlas_tpl_spec.hpp @@ -20,4 +20,22 @@ struct CudaBlasSingleton { } #endif +#ifdef KOKKOSKERNELS_ENABLE_TPL_MAGMA +#include "magma_v2.h" +#include "magma_lapack.h" + +namespace KokkosBlas { +namespace Impl { + +struct MagmaSingleton { + + MagmaSingleton(); + + static MagmaSingleton & singleton(); +}; + +} +} +#endif + #endif \ No newline at end of file diff --git a/unit_test/Makefile b/unit_test/Makefile index abf54844f6..aaad6d6db0 100644 --- a/unit_test/Makefile +++ b/unit_test/Makefile @@ -224,6 +224,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_CUDA), 1) OBJ_CUDA += Test_Cuda_Blas2_gemv.o OBJ_CUDA += Test_Cuda_Blas2_team_gemv.o OBJ_CUDA += Test_Cuda_Blas3_gemm.o #Not yet ready need to figure out how to handle CUBLAS + OBJ_CUDA += Test_Cuda_Blas_gesv.o #OBJ_CUDA += Test_Cuda_Sparse_spmv.o #OBJ_CUDA += Test_Cuda_Sparse_trsv.o #removing trsv from cuda unit test as it runs only sequential. OBJ_CUDA += Test_Cuda_Sparse_spgemm.o diff --git a/unit_test/blas/Test_Blas_gesv.hpp b/unit_test/blas/Test_Blas_gesv.hpp new file mode 100644 index 0000000000..88867f403d --- /dev/null +++ b/unit_test/blas/Test_Blas_gesv.hpp @@ -0,0 +1,271 @@ +#include +#include +#include + +#include +#include +#include +#include + +namespace Test { + +template +void impl_test_gesv(const char* mode, const char* padding, int N) { + typedef typename Device::execution_space execution_space; + typedef typename ViewTypeA::value_type ScalarA; + typedef Kokkos::Details::ArithTraits ats; + + Kokkos::Random_XorShift64_Pool rand_pool(13718); + + int ldda, lddb; + + if(padding[0]=='Y') {//rounded up to multiple of 32 + ldda = ((N+32-1)/32)*32; + lddb = ldda; + } + else { + ldda = N; + lddb = N; + } + + // Create device views + ViewTypeA A ( "A", ldda, N ); + ViewTypeB X0( "X0", N ); + ViewTypeB B ( "B", lddb ); + + // Create host mirrors of device views. + typename ViewTypeB::HostMirror h_X0 = Kokkos::create_mirror_view(X0); + typename ViewTypeB::HostMirror h_B = Kokkos::create_mirror(B); + + // Initialize data. + Kokkos::fill_random(A, rand_pool,Kokkos::rand,ScalarA >::max()); + Kokkos::fill_random(X0,rand_pool,Kokkos::rand,ScalarA >::max()); + + // Generate RHS B = A*X0. + ScalarA alpha = 1.0; + ScalarA beta = 0.0; + + KokkosBlas::gemv("N",alpha,A,X0,beta,B); Kokkos::fence(); + + // Deep copy device view to host view. + Kokkos::deep_copy( h_X0, X0 ); + + // Solve. + KokkosBlas::gesv(&mode[0],A,B); + Kokkos::fence(); + + // Get the solution vector. + Kokkos::deep_copy( h_B, B ); + + // Checking vs ref on CPU, this eps is about 10^-9 + typedef typename ats::mag_type mag_type; + const mag_type eps = 1.0e7 * ats::epsilon(); + bool test_flag = true; + for (int i=0; i eps ) { + test_flag = false; + //printf( " Error %d, pivot %c, padding %c: result( %.15lf ) != solution( %.15lf ) at (%ld)\n", N, mode[0], padding[0], ats::abs(h_B(i)), ats::abs(h_X0(i)), i ); + break; + } + } + ASSERT_EQ( test_flag, true ); + } + +template +void impl_test_gesv_mrhs(const char* mode, const char* padding, int N, int nrhs) { + typedef typename Device::execution_space execution_space; + typedef typename ViewTypeA::value_type ScalarA; + typedef Kokkos::Details::ArithTraits ats; + + Kokkos::Random_XorShift64_Pool rand_pool(13718); + + int ldda, lddb; + + if(padding[0]=='Y') {//rounded up to multiple of 32 + ldda = ((N+32-1)/32)*32; + lddb = ldda; + } + else { + ldda = N; + lddb = N; + } + + // Create device views + ViewTypeA A ( "A", ldda, N ); + ViewTypeB X0( "X0", N, nrhs ); + ViewTypeB B ( "B", lddb, nrhs ); + + // Create host mirrors of device views. + typename ViewTypeB::HostMirror h_X0 = Kokkos::create_mirror_view( X0 ); + typename ViewTypeB::HostMirror h_B = Kokkos::create_mirror( B ); + + // Initialize data. + Kokkos::fill_random(A, rand_pool,Kokkos::rand,ScalarA >::max()); + Kokkos::fill_random(X0,rand_pool,Kokkos::rand,ScalarA >::max()); + + // Generate RHS B = A*X0. + ScalarA alpha = 1.0; + ScalarA beta = 0.0; + + KokkosBlas::gemm("N","N",alpha,A,X0,beta,B); Kokkos::fence(); + + // Deep copy device view to host view. + Kokkos::deep_copy( h_X0, X0 ); + + // Solve. + KokkosBlas::gesv(&mode[0],A,B); + Kokkos::fence(); + + // Get the solution vector. + Kokkos::deep_copy( h_B, B ); + + // Checking vs ref on CPU, this eps is about 10^-9 + typedef typename ats::mag_type mag_type; + const mag_type eps = 1.0e7 * ats::epsilon(); + bool test_flag = true; + for (int j=0; j eps ) { + test_flag = false; + //printf( " Error %d, pivot %c, padding %c: result( %.15lf ) != solution( %.15lf ) at (%ld) at rhs %d\n", N, mode[0], padding[0], ats::abs(h_B(i,j)), ats::abs(h_X0(i,j)), i, j ); + break; + } + } + if (test_flag == false) break; + } + ASSERT_EQ( test_flag, true ); + } + +}//namespace Test + +template +int test_gesv(const char* mode) { + +#if defined(KOKKOSKERNELS_INST_LAYOUTLEFT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + typedef Kokkos::View view_type_a_ll; + typedef Kokkos::View view_type_b_ll; + Test::impl_test_gesv(&mode[0], "N", 0); //no padding + Test::impl_test_gesv(&mode[0], "N", 13); //no padding + Test::impl_test_gesv(&mode[0], "N", 179); //no padding + Test::impl_test_gesv(&mode[0], "N", 64); //no padding + Test::impl_test_gesv(&mode[0], "N", 1024);//no padding + Test::impl_test_gesv(&mode[0], "Y", 13); //padding + Test::impl_test_gesv(&mode[0], "Y", 179); //padding +#endif + +/* +#if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + typedef Kokkos::View view_type_a_lr; + typedef Kokkos::View view_type_b_lr; + Test::impl_test_gesv(&mode[0], "N", 0); //no padding + Test::impl_test_gesv(&mode[0], "N", 13); //no padding + Test::impl_test_gesv(&mode[0], "N", 179); //no padding + Test::impl_test_gesv(&mode[0], "N", 64); //no padding + Test::impl_test_gesv(&mode[0], "N", 1024);//no padding + Test::impl_test_gesv(&mode[0], "Y", 13); //padding + Test::impl_test_gesv(&mode[0], "Y", 179); //padding +#endif +*/ + + return 1; +} + +template +int test_gesv_mrhs(const char* mode) { + +#if defined(KOKKOSKERNELS_INST_LAYOUTLEFT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + typedef Kokkos::View view_type_a_ll; + typedef Kokkos::View view_type_b_ll; + Test::impl_test_gesv_mrhs(&mode[0], "N", 0, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 13, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 179, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 64, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 1024,5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "Y", 13, 5);//padding + Test::impl_test_gesv_mrhs(&mode[0], "Y", 179, 5);//padding +#endif + +/* +#if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + typedef Kokkos::View view_type_a_lr; + typedef Kokkos::View view_type_b_lr; + Test::impl_test_gesv_mrhs(&mode[0], "N", 0, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 13, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 179, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 64, 5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "N", 1024,5);//no padding + Test::impl_test_gesv_mrhs(&mode[0], "Y", 13, 5);//padding + Test::impl_test_gesv_mrhs(&mode[0], "Y", 179, 5);//padding +#endif +*/ + + return 1; +} + +#if defined( KOKKOSKERNELS_ENABLE_TPL_MAGMA ) + +#if defined(KOKKOSKERNELS_INST_FLOAT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +TEST_F( TestCategory, gesv_float ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_float"); + test_gesv ("N");//No pivoting + test_gesv ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} + +TEST_F( TestCategory, gesv_mrhs_float ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_mrhs_float"); + test_gesv_mrhs ("N");//No pivoting + test_gesv_mrhs ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} +#endif + +#if defined(KOKKOSKERNELS_INST_DOUBLE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +TEST_F( TestCategory, gesv_double ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_double"); + test_gesv ("N");//No pivoting + test_gesv ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} + +TEST_F( TestCategory, gesv_mrhs_double ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_mrhs_double"); + test_gesv_mrhs ("N");//No pivoting + test_gesv_mrhs ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} +#endif + +#if defined(KOKKOSKERNELS_INST_COMPLEX_DOUBLE) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +TEST_F( TestCategory, gesv_complex_double ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_complex_double"); + test_gesv,TestExecSpace> ("N");//No pivoting + test_gesv,TestExecSpace> ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} + +TEST_F( TestCategory, gesv_mrhs_complex_double ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_mrhs_complex_double"); + test_gesv_mrhs,TestExecSpace> ("N");//No pivoting + test_gesv_mrhs,TestExecSpace> ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} +#endif + +#if defined(KOKKOSKERNELS_INST_COMPLEX_FLOAT) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) +TEST_F( TestCategory, gesv_complex_float ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_complex_float"); + test_gesv,TestExecSpace> ("N");//No pivoting + test_gesv,TestExecSpace> ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} + +TEST_F( TestCategory, gesv_mrhs_complex_float ) { + Kokkos::Profiling::pushRegion("KokkosBlas::Test::gesv_mrhs_complex_float"); + test_gesv_mrhs,TestExecSpace> ("N");//No pivoting + test_gesv_mrhs,TestExecSpace> ("Y");//Partial pivoting + Kokkos::Profiling::popRegion(); +} +#endif + +#endif//KOKKOSKERNELS_ENABLE_TPL_MAGMA \ No newline at end of file diff --git a/unit_test/cuda/Test_Cuda_Blas_gesv.cpp b/unit_test/cuda/Test_Cuda_Blas_gesv.cpp new file mode 100644 index 0000000000..7e0632a6b7 --- /dev/null +++ b/unit_test/cuda/Test_Cuda_Blas_gesv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/openmp/Test_OpenMP_Blas_gesv.cpp b/unit_test/openmp/Test_OpenMP_Blas_gesv.cpp new file mode 100644 index 0000000000..b5687118b0 --- /dev/null +++ b/unit_test/openmp/Test_OpenMP_Blas_gesv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/serial/Test_Serial_Blas_gesv.cpp b/unit_test/serial/Test_Serial_Blas_gesv.cpp new file mode 100644 index 0000000000..e8a13068de --- /dev/null +++ b/unit_test/serial/Test_Serial_Blas_gesv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/threads/Test_Threads_Blas_gesv.cpp b/unit_test/threads/Test_Threads_Blas_gesv.cpp new file mode 100644 index 0000000000..ec5d7a1528 --- /dev/null +++ b/unit_test/threads/Test_Threads_Blas_gesv.cpp @@ -0,0 +1,2 @@ +#include +#include From 238bd6ed1803c9ea22512e8675355428c7ebd4b6 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Mon, 8 Apr 2019 14:55:49 -0600 Subject: [PATCH 162/190] KokkosBatched - promotion preparation. --- src/batched/KokkosBatched_Util.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/batched/KokkosBatched_Util.hpp b/src/batched/KokkosBatched_Util.hpp index 361ccd7a7f..cf913ab0f1 100644 --- a/src/batched/KokkosBatched_Util.hpp +++ b/src/batched/KokkosBatched_Util.hpp @@ -3,7 +3,8 @@ /// \author Kyungjoo Kim (kyukim@sandia.gov) -//#define __KOKKOSBATCHED_PROMOTION__ 1 +// no experimental name space guard for trilinos +#define __KOKKOSBATCHED_PROMOTION__ 1 #include #include From 595bce8d941f9e717f3339bc31961fac9f0dee5e Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 09:46:55 -0600 Subject: [PATCH 163/190] This script generates .cpp source files for specializations of --- ...plex_double__LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ..._double__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ..._double__LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...mplex_float__LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...x_float__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_float__LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_double_LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...t_double_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...t_double_LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...c_inst_float_LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...st_float_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_float_LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ 64 files changed, 3712 insertions(+) create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..fd787c319d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..98a979c718 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..1dd79088f1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..5afeb7997f --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..8381ac5d66 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..728d469ce9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..112a54e5fa --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..1a380dc425 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..953df7c396 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7f995d19f9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..515979aad9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..ccf1bd0791 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..2e9ebb23f5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..0234409767 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..376bc24b5b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..27a9c60994 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..65b38c3e60 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..4206e3ce98 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..2cf51d2589 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..c22ba492c7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..1b3bc65599 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..08ffa9b651 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b92d08ea22 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..528938d66e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a945a7b9ec --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ff527fc0f6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..43d6cc9f62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..8805876e43 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..e0bf33a72b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..659fa900d1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..26acb45b3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..22408149d0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..c945f2c06b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..fff1c3b626 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..717dc7d87e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..066272e0c5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d627e891c1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..1acec7c9c2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..89d9f2dd91 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..36dc395405 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..eab4b99a62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8e6111f463 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..a2bb40158a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..0961bf6f69 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..ef97b25cbb --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..893aeb7204 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..5affc246f5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..cf6d30469a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..d52a61d5bc --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7b58ef1e4d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8e33b30d69 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..25926c190e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..9f222c31cf --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c23de17e62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..8f1ccf96c9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..ef72647e81 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..8e900d7c04 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..0c806bab5f --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..d253ed3989 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..aec608a9e2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..5bd29ce5bd --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..ba2211f89d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..c862ee53ce --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..7cff89be2c --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif From 2779506d18d09f8816ef67e2bab7f1ffe1979282 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 09:49:35 -0600 Subject: [PATCH 164/190] Wrong files --- ...plex_double__LayoutLeft_Cuda_CudaSpace.cpp | 58 ------------------- ...x_double__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...lex_double__LayoutLeft_OpenMP_HBWSpace.cpp | 58 ------------------- ...ex_double__LayoutLeft_OpenMP_HostSpace.cpp | 58 ------------------- ...lex_double__LayoutLeft_Serial_HBWSpace.cpp | 58 ------------------- ...ex_double__LayoutLeft_Serial_HostSpace.cpp | 58 ------------------- ...ex_double__LayoutLeft_Threads_HBWSpace.cpp | 58 ------------------- ...x_double__LayoutLeft_Threads_HostSpace.cpp | 58 ------------------- ...lex_double__LayoutRight_Cuda_CudaSpace.cpp | 58 ------------------- ..._double__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...ex_double__LayoutRight_OpenMP_HBWSpace.cpp | 58 ------------------- ...x_double__LayoutRight_OpenMP_HostSpace.cpp | 58 ------------------- ...ex_double__LayoutRight_Serial_HBWSpace.cpp | 58 ------------------- ...x_double__LayoutRight_Serial_HostSpace.cpp | 58 ------------------- ...x_double__LayoutRight_Threads_HBWSpace.cpp | 58 ------------------- ..._double__LayoutRight_Threads_HostSpace.cpp | 58 ------------------- ...mplex_float__LayoutLeft_Cuda_CudaSpace.cpp | 58 ------------------- ...ex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...plex_float__LayoutLeft_OpenMP_HBWSpace.cpp | 58 ------------------- ...lex_float__LayoutLeft_OpenMP_HostSpace.cpp | 58 ------------------- ...plex_float__LayoutLeft_Serial_HBWSpace.cpp | 58 ------------------- ...lex_float__LayoutLeft_Serial_HostSpace.cpp | 58 ------------------- ...lex_float__LayoutLeft_Threads_HBWSpace.cpp | 58 ------------------- ...ex_float__LayoutLeft_Threads_HostSpace.cpp | 58 ------------------- ...plex_float__LayoutRight_Cuda_CudaSpace.cpp | 58 ------------------- ...x_float__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...lex_float__LayoutRight_OpenMP_HBWSpace.cpp | 58 ------------------- ...ex_float__LayoutRight_OpenMP_HostSpace.cpp | 58 ------------------- ...lex_float__LayoutRight_Serial_HBWSpace.cpp | 58 ------------------- ...ex_float__LayoutRight_Serial_HostSpace.cpp | 58 ------------------- ...ex_float__LayoutRight_Threads_HBWSpace.cpp | 58 ------------------- ...x_float__LayoutRight_Threads_HostSpace.cpp | 58 ------------------- ..._inst_double_LayoutLeft_Cuda_CudaSpace.cpp | 58 ------------------- ...st_double_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...inst_double_LayoutLeft_OpenMP_HBWSpace.cpp | 58 ------------------- ...nst_double_LayoutLeft_OpenMP_HostSpace.cpp | 58 ------------------- ...inst_double_LayoutLeft_Serial_HBWSpace.cpp | 58 ------------------- ...nst_double_LayoutLeft_Serial_HostSpace.cpp | 58 ------------------- ...nst_double_LayoutLeft_Threads_HBWSpace.cpp | 58 ------------------- ...st_double_LayoutLeft_Threads_HostSpace.cpp | 58 ------------------- ...inst_double_LayoutRight_Cuda_CudaSpace.cpp | 58 ------------------- ...t_double_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...nst_double_LayoutRight_OpenMP_HBWSpace.cpp | 58 ------------------- ...st_double_LayoutRight_OpenMP_HostSpace.cpp | 58 ------------------- ...nst_double_LayoutRight_Serial_HBWSpace.cpp | 58 ------------------- ...st_double_LayoutRight_Serial_HostSpace.cpp | 58 ------------------- ...st_double_LayoutRight_Threads_HBWSpace.cpp | 58 ------------------- ...t_double_LayoutRight_Threads_HostSpace.cpp | 58 ------------------- ...c_inst_float_LayoutLeft_Cuda_CudaSpace.cpp | 58 ------------------- ...nst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 ------------------- ..._inst_float_LayoutLeft_OpenMP_HBWSpace.cpp | 58 ------------------- ...inst_float_LayoutLeft_OpenMP_HostSpace.cpp | 58 ------------------- ..._inst_float_LayoutLeft_Serial_HBWSpace.cpp | 58 ------------------- ...inst_float_LayoutLeft_Serial_HostSpace.cpp | 58 ------------------- ...inst_float_LayoutLeft_Threads_HBWSpace.cpp | 58 ------------------- ...nst_float_LayoutLeft_Threads_HostSpace.cpp | 58 ------------------- ..._inst_float_LayoutRight_Cuda_CudaSpace.cpp | 58 ------------------- ...st_float_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 ------------------- ...inst_float_LayoutRight_OpenMP_HBWSpace.cpp | 58 ------------------- ...nst_float_LayoutRight_OpenMP_HostSpace.cpp | 58 ------------------- ...inst_float_LayoutRight_Serial_HBWSpace.cpp | 58 ------------------- ...nst_float_LayoutRight_Serial_HostSpace.cpp | 58 ------------------- ...nst_float_LayoutRight_Threads_HBWSpace.cpp | 58 ------------------- ...st_float_LayoutRight_Threads_HostSpace.cpp | 58 ------------------- 64 files changed, 3712 deletions(-) delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp delete mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp deleted file mode 100644 index fd787c319d..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 98a979c718..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp deleted file mode 100644 index 1dd79088f1..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp deleted file mode 100644 index 5afeb7997f..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp deleted file mode 100644 index 8381ac5d66..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp deleted file mode 100644 index 728d469ce9..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp deleted file mode 100644 index 112a54e5fa..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp deleted file mode 100644 index 1a380dc425..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp deleted file mode 100644 index 953df7c396..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 7f995d19f9..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp deleted file mode 100644 index 515979aad9..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp deleted file mode 100644 index ccf1bd0791..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp deleted file mode 100644 index 2e9ebb23f5..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp deleted file mode 100644 index 0234409767..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp deleted file mode 100644 index 376bc24b5b..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp deleted file mode 100644 index 27a9c60994..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp deleted file mode 100644 index 65b38c3e60..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 4206e3ce98..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp deleted file mode 100644 index 2cf51d2589..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp deleted file mode 100644 index c22ba492c7..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp deleted file mode 100644 index 1b3bc65599..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp deleted file mode 100644 index 08ffa9b651..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp deleted file mode 100644 index b92d08ea22..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp deleted file mode 100644 index 528938d66e..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp deleted file mode 100644 index a945a7b9ec..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index ff527fc0f6..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp deleted file mode 100644 index 43d6cc9f62..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp deleted file mode 100644 index 8805876e43..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp deleted file mode 100644 index e0bf33a72b..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp deleted file mode 100644 index 659fa900d1..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp deleted file mode 100644 index 26acb45b3a..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp deleted file mode 100644 index 22408149d0..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp deleted file mode 100644 index c945f2c06b..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index fff1c3b626..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp deleted file mode 100644 index 717dc7d87e..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp deleted file mode 100644 index 066272e0c5..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp deleted file mode 100644 index d627e891c1..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp deleted file mode 100644 index 1acec7c9c2..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp deleted file mode 100644 index 89d9f2dd91..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp deleted file mode 100644 index 36dc395405..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp deleted file mode 100644 index eab4b99a62..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 8e6111f463..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp deleted file mode 100644 index a2bb40158a..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp deleted file mode 100644 index 0961bf6f69..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp deleted file mode 100644 index ef97b25cbb..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp deleted file mode 100644 index 893aeb7204..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp deleted file mode 100644 index 5affc246f5..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp deleted file mode 100644 index cf6d30469a..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_DOUBLE) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp deleted file mode 100644 index d52a61d5bc..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 7b58ef1e4d..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp deleted file mode 100644 index 8e33b30d69..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp deleted file mode 100644 index 25926c190e..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp deleted file mode 100644 index 9f222c31cf..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp deleted file mode 100644 index c23de17e62..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp deleted file mode 100644 index 8f1ccf96c9..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp deleted file mode 100644 index ef72647e81..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp deleted file mode 100644 index 8e900d7c04..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp deleted file mode 100644 index 0c806bab5f..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp deleted file mode 100644 index d253ed3989..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp deleted file mode 100644 index aec608a9e2..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp deleted file mode 100644 index 5bd29ce5bd..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp deleted file mode 100644 index ba2211f89d..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp deleted file mode 100644 index c862ee53ce..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) -} // Impl -} // KokkosBlas -#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp deleted file mode 100644 index 7cff89be2c..0000000000 --- a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* -//@HEADER -// ************************************************************************ -// -// KokkosKernels 0.9: Linear Algebra and Graph Kernels -// Copyright 2017 Sandia Corporation -// -// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, -// the U.S. Government retains certain rights in this software. -// -// 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. -// -// 3. Neither the name of the Corporation nor the names of the -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE -// 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. -// -// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) -// -// ************************************************************************ -//@HEADER -*/ - - -#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true -#include "KokkosKernels_config.h" -#if defined (KOKKOSKERNELS_INST_FLOAT) \ - && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ - && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ - && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) -#include "KokkosBlas_gesv_spec.hpp" - -namespace KokkosBlas { -namespace Impl { - KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) -} // Impl -} // KokkosBlas -#endif From 0856055bbde1ffef20a7299a56aae59f5f2f7c88 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 09:52:14 -0600 Subject: [PATCH 165/190] Add .cpp source files for specializations of gesv --- ...plex_double__LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_double__LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ..._double__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_double__LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...x_double__LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ..._double__LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...mplex_float__LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...plex_float__LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...x_float__LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...lex_float__LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...ex_float__LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...x_float__LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_double_LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_double_LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...t_double_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_double_LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...st_double_LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...t_double_LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ...c_inst_float_LayoutLeft_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutLeft_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutLeft_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutLeft_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutLeft_Threads_HostSpace.cpp | 58 +++++++++++++++++++ ..._inst_float_LayoutRight_Cuda_CudaSpace.cpp | 58 +++++++++++++++++++ ...st_float_LayoutRight_Cuda_CudaUVMSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutRight_OpenMP_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_OpenMP_HostSpace.cpp | 58 +++++++++++++++++++ ...inst_float_LayoutRight_Serial_HBWSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_Serial_HostSpace.cpp | 58 +++++++++++++++++++ ...nst_float_LayoutRight_Threads_HBWSpace.cpp | 58 +++++++++++++++++++ ...st_float_LayoutRight_Threads_HostSpace.cpp | 58 +++++++++++++++++++ 64 files changed, 3712 insertions(+) create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..fd787c319d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..98a979c718 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..1dd79088f1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..5afeb7997f --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..8381ac5d66 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..728d469ce9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..112a54e5fa --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..1a380dc425 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..953df7c396 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7f995d19f9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..515979aad9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..ccf1bd0791 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..2e9ebb23f5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..0234409767 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..376bc24b5b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..27a9c60994 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_double__LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..65b38c3e60 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..4206e3ce98 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..2cf51d2589 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..c22ba492c7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..1b3bc65599 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..08ffa9b651 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b92d08ea22 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..528938d66e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a945a7b9ec --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ff527fc0f6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..43d6cc9f62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..8805876e43 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..e0bf33a72b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..659fa900d1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..26acb45b3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..22408149d0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_Kokkos_complex_float__LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(Kokkos::complex, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..c945f2c06b --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..fff1c3b626 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..717dc7d87e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..066272e0c5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d627e891c1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..1acec7c9c2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..89d9f2dd91 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..36dc395405 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..eab4b99a62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8e6111f463 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..a2bb40158a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..0961bf6f69 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..ef97b25cbb --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..893aeb7204 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..5affc246f5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..cf6d30469a --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_double_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(double, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..d52a61d5bc --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7b58ef1e4d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8e33b30d69 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..25926c190e --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..9f222c31cf --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c23de17e62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..8f1ccf96c9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..ef72647e81 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..8e900d7c04 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..0c806bab5f --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..d253ed3989 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..aec608a9e2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..5bd29ce5bd --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..ba2211f89d --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..c862ee53ce --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosBlas +#endif diff --git a/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..7cff89be2c --- /dev/null +++ b/src/impl/generated_specializations_cpp/gesv/KokkosBlas_gesv_eti_spec_inst_float_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,58 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) +#include "KokkosBlas_gesv_spec.hpp" + +namespace KokkosBlas { +namespace Impl { + KOKKOSBLAS_GESV_ETI_SPEC_INST(float, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosBlas +#endif From 007092f7b6d2d391422c517ce2ae9676d159ae2d Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 10:21:52 -0600 Subject: [PATCH 166/190] Modify script to generate.cpp source files for specializations --- scripts/generate_specialization.bash | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scripts/generate_specialization.bash b/scripts/generate_specialization.bash index e0bd7bfe03..3338106ef5 100755 --- a/scripts/generate_specialization.bash +++ b/scripts/generate_specialization.bash @@ -77,3 +77,6 @@ ${KOKKOSKERNELS_PATH}/scripts/generate_specialization_function.bash gemv KokkosB #gemm ${KOKKOSKERNELS_PATH}/scripts/generate_specialization_function.bash gemm KokkosBlas3_gemm KokkosBlas3_gemm_spec.hpp KokkosBlas ${KOKKOSKERNELS_PATH} + +#gesv +${KOKKOSKERNELS_PATH}/scripts/generate_specialization_function.bash gesv KokkosBlas_gesv KokkosBlas_gesv_spec.hpp KokkosBlas ${KOKKOSKERNELS_PATH} \ No newline at end of file From d8f64f8ad2d23e78b46d83c178e6c39e14cb8ea7 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 10:25:00 -0600 Subject: [PATCH 167/190] Add CMake changes for Trilinos side --- CMakeLists.txt | 7 +++++++ cmake/Dependencies.cmake | 2 +- cmake/KokkosKernels_config.h.in | 2 ++ 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 26cd2ca2cc..db44f711b7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -336,6 +336,10 @@ IF(${Kokkos_ENABLE_Cuda}) SET(KOKKOSKERNELS_ENABLE_TPL_CUSPARSE ${TPL_ENABLE_CUSPARSE}) ENDIF() ENDIF() + + IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_MAGMA) + SET(KOKKOSKERNELS_ENABLE_TPL_MAGMA ON) + ENDIF() ENDIF() IF (KOKKOSKERNELS_ENABLE_TPL_BLAS) @@ -350,6 +354,9 @@ ENDIF() IF (KOKKOSKERNELS_ENABLE_TPL_CUBLAS) LIST(APPEND TPL_LIST "CUBLAS") ENDIF() +IF (KOKKOSKERNELS_ENABLE_TPL_MAGMA) + LIST(APPEND TPL_LIST "MAGMA") +ENDIF() # ================================================================== # Fortran Complex BLAS diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 8485862498..7eef4784a0 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -1,5 +1,5 @@ TRIBITS_PACKAGE_DEFINE_DEPENDENCIES( LIB_REQUIRED_PACKAGES KokkosCore KokkosContainers KokkosAlgorithms - LIB_OPTIONAL_TPLS quadmath MKL BLAS LAPACK CUSPARSE + LIB_OPTIONAL_TPLS quadmath MKL BLAS LAPACK CUSPARSE MAGMA TEST_OPTIONAL_TPLS yaml-cpp ) diff --git a/cmake/KokkosKernels_config.h.in b/cmake/KokkosKernels_config.h.in index f83eec704f..a5e5b37a3e 100644 --- a/cmake/KokkosKernels_config.h.in +++ b/cmake/KokkosKernels_config.h.in @@ -87,6 +87,8 @@ #cmakedefine KOKKOSKERNELS_ENABLE_TPL_CUSPARSE /* CUBLAS */ #cmakedefine KOKKOSKERNELS_ENABLE_TPL_CUBLAS +/* MAGMA */ +#cmakedefine KOKKOSKERNELS_ENABLE_TPL_MAGMA /* if MKL, BLAS is also defined */ #if defined(KOKKOSKERNELS_ENABLE_TPL_MKL) From 4df6f9fbc684fa969e3258c17fbca7698c3e5a3f Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Wed, 10 Apr 2019 10:36:38 -0600 Subject: [PATCH 168/190] Add CMake changes for Trilinos side --- src/CMakeLists.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3b4914ae84..46b5b72abc 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -16,6 +16,12 @@ APPEND_GLOB(HEADERS ${DIR}/generated_specializations_hpp/*.hpp) SET_AND_INC_DIRS(DIR ${CMAKE_CURRENT_SOURCE_DIR}/impl/tpls) APPEND_GLOB(HEADERS ${DIR}/*.hpp) +#Blas Cuda wrapper +IF (KOKKOSKERNELS_ENABLE_TPL_CUBLAS OR KOKKOSKERNELS_ENABLE_TPL_MAGMA) + APPEND_GLOB(HEADERS ${DIR}/impl/tpls/KokkosBlas_Cuda_tpl.hpp) + APPEND_GLOB(SOURCES ${DIR}/impl/tpls/KokkosBlas_Cuda_tpl.cpp) +ENDIF() + #Include BLAS SET_AND_INC_DIRS(DIR ${CMAKE_CURRENT_SOURCE_DIR}/blas) From 7c4188347d6e4ca740945f8977b0bee0f4b1d9d9 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Fri, 12 Apr 2019 13:54:05 -0600 Subject: [PATCH 169/190] Remove redundant OpenBLAS link flag --- Makefile.kokkos-kernels | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Makefile.kokkos-kernels b/Makefile.kokkos-kernels index 6c15670832..0ac405ca27 100644 --- a/Makefile.kokkos-kernels +++ b/Makefile.kokkos-kernels @@ -35,7 +35,6 @@ MKL_PATH ?= ${SEMS_INTEL_ROOT}/mkl MKL_LIBS ?= -L${MKL_PATH}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl -L${MKL_PATH}/../compiler/lib/intel64 MAGMA_PATH ?= ${MAGMADIR} -OPENBLAS_PATH ?= ${OPENBLAS_ROOT} default-kokkos-kernels: kokkoskernels-build-lib echo "Start Build" @@ -314,8 +313,8 @@ ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc) CUDA_PATH ?= $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=) KOKKOSKERNELS_CPPFLAGS += -DADD_ -I${MAGMA_PATH}/include -I${MAGMA_PATH}/sparse/include -I${CUDA_PATH}/include - KOKKOSKERNELS_LDFLAGS += -L${MAGMA_PATH}/lib -L${CUDA_PATH}/lib64 -L${OPENBLAS_PATH}/lib - KOKKOSKERNELS_LIBS += -lmagma_sparse -lmagma -lcublas -lcudart -lcusparse -lopenblas -fopenmp + KOKKOSKERNELS_LDFLAGS += -L${MAGMA_PATH}/lib -L${CUDA_PATH}/lib64 + KOKKOSKERNELS_LIBS += -lmagma_sparse -lmagma -lcublas -lcudart -lcusparse -fopenmp tmp := $(shell echo "\#define KOKKOSKERNELS_ENABLE_TPL_MAGMA" >> KokkosKernels_config.tmp ) endif From 193ee44819f4f251fe536d26faa90479c4a5aae9 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Fri, 12 Apr 2019 13:56:27 -0600 Subject: [PATCH 170/190] Fix some pattern matching errors --- src/blas/KokkosBlas_gesv.hpp | 2 +- src/blas/impl/KokkosBlas_gesv_spec.hpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/blas/KokkosBlas_gesv.hpp b/src/blas/KokkosBlas_gesv.hpp index f018f1fba8..4be944d5dc 100644 --- a/src/blas/KokkosBlas_gesv.hpp +++ b/src/blas/KokkosBlas_gesv.hpp @@ -132,5 +132,5 @@ gesv (const char pivot[], } // namespace KokkosBlas -#endif // KOKKOSBLAS_TRSV_HPP_ +#endif // KOKKOSBLAS_GESV_HPP_ diff --git a/src/blas/impl/KokkosBlas_gesv_spec.hpp b/src/blas/impl/KokkosBlas_gesv_spec.hpp index ac8d7803d4..0580db9cc4 100644 --- a/src/blas/impl/KokkosBlas_gesv_spec.hpp +++ b/src/blas/impl/KokkosBlas_gesv_spec.hpp @@ -139,7 +139,7 @@ struct GESV< AMatrix, BXMV, false, KOKKOSKERNELS_IMPL_COMPILE_LIBRARY>{ Kokkos::MemoryTraits >, \ false, true >; \ -#define KOKKOSBLAS_TRSV_ETI_SPEC_INST( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ +#define KOKKOSBLAS_GESV_ETI_SPEC_INST( SCALAR_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ template struct \ GESV< Kokkos::View, \ From 048f65f212185535add5450bf126e968bc8dbb15 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Mon, 22 Apr 2019 00:45:54 -0600 Subject: [PATCH 171/190] Fix Cmake logic for MAGMA --- CMakeLists.txt | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index db44f711b7..863857095a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -337,8 +337,17 @@ IF(${Kokkos_ENABLE_Cuda}) ENDIF() ENDIF() - IF (NOT DEFINED KOKKOSKERNELS_ENABLE_TPL_MAGMA) - SET(KOKKOSKERNELS_ENABLE_TPL_MAGMA ON) + IF (DEFINED KOKKOSKERNELS_ENABLE_TPL_MAGMA) + IF (KOKKOSKERNELS_ENABLE_TPL_MAGMA) + IF (NOT TPL_ENABLE_MAGMA) + MESSAGE( WARNING "KOKKOSKERNELS_ENABLE_TPL_MAGMA is ON but TPL_ENABLE_MAGMA is OFF. Please set TPL_ENABLE_MAGMA:BOOL=ON") + SET(KOKKOSKERNELS_ENABLE_TPL_MAGMA OFF) + ENDIF() + ENDIF() + ELSE() + IF (TPL_ENABLE_MAGMA) + SET(KOKKOSKERNELS_ENABLE_TPL_MAGMA ${TPL_ENABLE_MAGMA}) + ENDIF() ENDIF() ENDIF() From 3a455073dd10732df201591f80f936588eea3f5b Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Mon, 22 Apr 2019 14:30:23 -0600 Subject: [PATCH 172/190] Allow users to provide how Fortran functions are name-mangled KOKKOSKERNELS_OPTIONS --- Makefile.kokkos-kernels | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/Makefile.kokkos-kernels b/Makefile.kokkos-kernels index 0ac405ca27..0abd314f4b 100644 --- a/Makefile.kokkos-kernels +++ b/Makefile.kokkos-kernels @@ -80,17 +80,30 @@ tmp := $(shell echo "\#define KOKKOSKERNELS_CONFIG_H_" >> KokkosKernels_config.t # default mangling scheme with a single under score KOKKOSKERNELS_FORTRAN_GLOBAL = name\#\#_ +ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + MAGMA_FORTRAN_MANGLING = ADD_ +endif + KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_DOUBLE_UNDERSCORES := $(strip $(shell echo $(KOKKOSKERNELS_OPTIONS) | grep "blas-mangle__" | wc -l)) ifeq ($(KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_DOUBLE_UNDERSCORES), 1) KOKKOSKERNELS_FORTRAN_GLOBAL = name\#\#__ + ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + $(error MAGMA does not prefer Fortran mangling with double underscore) + endif else KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_SINGLE_UNDERSCORE := $(strip $(shell echo $(KOKKOSKERNELS_OPTIONS) | grep "blas-mangle_" | wc -l)) ifeq ($(KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_SINGLE_UNDERSCORE), 1) KOKKOSKERNELS_FORTRAN_GLOBAL = name\#\#_ + ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + MAGMA_FORTRAN_MANGLING = ADD_ + endif else KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_NO_UNDERSCORE := $(strip $(shell echo $(KOKKOSKERNELS_OPTIONS) | grep "blas-mangle" | wc -l)) ifeq ($(KOKKOSKERNELS_INTERNAL_OVERRIDE_FORTRAN_MANGLING_WITH_NO_UNDERSCORE), 1) KOKKOSKERNELS_FORTRAN_GLOBAL = name\#\# + ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) + MAGMA_FORTRAN_MANGLING = NOCHANGE + endif endif endif endif @@ -312,7 +325,7 @@ endif ifeq (${KOKKOSKERNELS_INTERNAL_ENABLE_MAGMA}, 1) KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc) CUDA_PATH ?= $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=) - KOKKOSKERNELS_CPPFLAGS += -DADD_ -I${MAGMA_PATH}/include -I${MAGMA_PATH}/sparse/include -I${CUDA_PATH}/include + KOKKOSKERNELS_CPPFLAGS += -D${MAGMA_FORTRAN_MANGLING} -I${MAGMA_PATH}/include -I${MAGMA_PATH}/sparse/include -I${CUDA_PATH}/include KOKKOSKERNELS_LDFLAGS += -L${MAGMA_PATH}/lib -L${CUDA_PATH}/lib64 KOKKOSKERNELS_LIBS += -lmagma_sparse -lmagma -lcublas -lcudart -lcusparse -fopenmp From 35b6dafde8c75b149955d662bd115b972a636beb Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Thu, 9 May 2019 13:00:07 -0600 Subject: [PATCH 173/190] Update module list with magma and cuda 10 --- scripts/test_all_sandia | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/scripts/test_all_sandia b/scripts/test_all_sandia index 6d3da56efd..72b6aac425 100755 --- a/scripts/test_all_sandia +++ b/scripts/test_all_sandia @@ -404,6 +404,7 @@ elif [ "$MACHINE" = "apollo" ]; then BASE_MODULE_LIST="sems-env,kokkos-env,kokkos-hwloc/1.10.1/base,sems-/" CUDA_MODULE_LIST="sems-env,kokkos-env,kokkos-/,sems-gcc/5.3.0,kokkos-hwloc/1.10.1/base" + CUDA10_MODULE_LIST="sems-env,kokkos-env,/,sems-gcc/6.1.0,kokkos-hwloc/1.10.1/base,magma" CLANG_MODULE_LIST="sems-env,kokkos-env,/,cuda/9.0.69" CLANG7_MODULE_LIST="sems-env,kokkos-env,/,cuda/9.1" @@ -412,7 +413,7 @@ elif [ "$MACHINE" = "apollo" ]; then BUILD_LIST_CUDA_NVCC="Cuda_Serial,Cuda_OpenMP" BUILD_LIST_CUDA_CLANG="Cuda_Serial,Cuda_Pthread" BUILD_LIST_CLANG="Serial,Pthread,OpenMP" - + if [ "$SPOT_CHECK" = "True" ]; then # Format: (compiler module-list build-list exe-name warning-flag) COMPILERS=("gcc/4.8.4 $BASE_MODULE_LIST "OpenMP,Pthread" g++ $GCC_WARNING_FLAGS" @@ -421,6 +422,7 @@ elif [ "$MACHINE" = "apollo" ]; then "clang/3.9.0 $BASE_MODULE_LIST "Pthread_Serial" clang++ $CLANG_WARNING_FLAGS" "clang/6.0 $CLANG_MODULE_LIST "Cuda_Pthread" clang++ $CUDA_WARNING_FLAGS" "cuda/9.1 $CUDA_MODULE_LIST "Cuda_OpenMP" $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" + "cuda/10.0 $CUDA10_MODULE_LIST "Cuda_OpenMP" ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS" ) else # Format: (compiler module-list build-list exe-name warning-flag) From 40eb12208778e98fc88ea7f106cc588b02d39f02 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Sun, 12 May 2019 16:31:59 -0600 Subject: [PATCH 174/190] Add CXX flag change for MAGMA using F77_BLAS_MANGLE detected from Trilinos --- CMakeLists.txt | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 863857095a..bd9a811538 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -365,6 +365,13 @@ IF (KOKKOSKERNELS_ENABLE_TPL_CUBLAS) ENDIF() IF (KOKKOSKERNELS_ENABLE_TPL_MAGMA) LIST(APPEND TPL_LIST "MAGMA") + IF (F77_BLAS_MANGLE STREQUAL "(name,NAME) name ## _") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DADD_ -fopenmp -lgfortran") + ELSEIF (F77_BLAS_MANGLE STREQUAL "(name,NAME) name ## __") + MESSAGE(FATAL_ERROR "MAGMA does not prefer Fortran mangling with double underscore") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOCHANGE -fopenmp -lgfortran") + ENDIF() ENDIF() # ================================================================== From ed0045895169a2a91de1eb98f87d490ad63f9526 Mon Sep 17 00:00:00 2001 From: Vinh Dang Date: Mon, 13 May 2019 14:19:58 -0600 Subject: [PATCH 175/190] Update: Set CXX flag according to MAGMA documentation (single underscore, uppecase, no change) using F77_BLAS_MANGLE detected from Trilinos --- CMakeLists.txt | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bd9a811538..6ad87dd87a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -367,10 +367,12 @@ IF (KOKKOSKERNELS_ENABLE_TPL_MAGMA) LIST(APPEND TPL_LIST "MAGMA") IF (F77_BLAS_MANGLE STREQUAL "(name,NAME) name ## _") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DADD_ -fopenmp -lgfortran") - ELSEIF (F77_BLAS_MANGLE STREQUAL "(name,NAME) name ## __") - MESSAGE(FATAL_ERROR "MAGMA does not prefer Fortran mangling with double underscore") - ELSE () + ELSEIF (F77_BLAS_MANGLE STREQUAL "(name,NAME) NAME") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUPCASE -fopenmp -lgfortran") + ELSEIF (F77_BLAS_MANGLE STREQUAL "(name,NAME) name") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOCHANGE -fopenmp -lgfortran") + ELSE () + MESSAGE(FATAL_ERROR "F77_BLAS_MANGLE ${F77_BLAS_MANGLE} detected while MAGMA only accepts Fortran mangling that is one of single underscore (-DADD_), uppercase (-DUPCASE), and no change (-DNOCHANGE)") ENDIF() ENDIF() From b5f0e08bb3051f438ebcb1e4f1d086eafd1169c0 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 15 May 2019 12:32:47 -0600 Subject: [PATCH 176/190] Update fences in agreement with Kokkos deprecations See kokkos/kokkos#2140 The fence as a static member function of execution spaces was deprecated, made non-static. --- Makefile.kokkos-kernels | 16 +++--- example/fenl/CGSolve.hpp | 4 +- example/fenl/VectorImport.hpp | 2 +- example/fenl/fenl_functors.hpp | 14 ++--- example/fenl/fenl_impl.hpp | 6 +- .../batched/KokkosBatched_Test_Gemm_Host.hpp | 24 ++++---- .../batched/KokkosBatched_Test_Gemv_Host.hpp | 12 ++-- .../batched/KokkosBatched_Test_LU_Host.hpp | 16 +++--- .../batched/KokkosBatched_Test_Trsm_Host.hpp | 20 +++---- perf_test/graph/KokkosGraph_run_triangle.hpp | 4 +- perf_test/sparse/KokkosSparse_pcg.hpp | 28 +++++----- perf_test/sparse/KokkosSparse_run_spgemm.hpp | 8 +-- src/batched/KokkosBatched_Util.hpp | 2 +- src/common/KokkosKernels_PrintUtils.hpp | 2 +- src/common/KokkosKernels_SimpleUtils.hpp | 2 +- src/common/KokkosKernels_SparseUtils.hpp | 52 ++++++++--------- src/common/KokkosKernels_Utils.hpp | 56 +++++++++---------- .../KokkosGraph_Distance1ColorHandle.hpp | 2 +- .../impl/KokkosGraph_Distance1Color_impl.hpp | 36 ++++++------ .../impl/KokkosGraph_Distance2Color_impl.hpp | 8 +-- src/sparse/KokkosSparse_spadd.hpp | 24 ++++---- .../impl/KokkosSparse_gauss_seidel_impl.hpp | 40 ++++++------- .../impl/KokkosSparse_spgemm_CUSP_impl.hpp | 2 +- .../impl/KokkosSparse_spgemm_imp_outer.hpp | 16 +++--- .../impl/KokkosSparse_spgemm_impl_color.hpp | 12 ++-- .../KokkosSparse_spgemm_impl_compression.hpp | 14 ++--- .../impl/KokkosSparse_spgemm_impl_kkmem.hpp | 14 ++--- .../KokkosSparse_spgemm_impl_memaccess.hpp | 6 +- .../impl/KokkosSparse_spgemm_impl_speed.hpp | 10 ++-- .../KokkosSparse_spgemm_impl_symbolic.hpp | 24 ++++---- .../KokkosSparse_spgemm_impl_triangle.hpp | 6 +- ...se_spgemm_impl_triangle_no_compression.hpp | 4 +- .../KokkosSparse_spgemm_viennaCL_impl.hpp | 6 +- 33 files changed, 246 insertions(+), 246 deletions(-) diff --git a/Makefile.kokkos-kernels b/Makefile.kokkos-kernels index 274cd2ef85..212f9d3d5b 100644 --- a/Makefile.kokkos-kernels +++ b/Makefile.kokkos-kernels @@ -464,16 +464,16 @@ endif ifeq ($(KOKKOS_OS),Linux) COPY_FLAG = -u endif -ifeq ($(KOKKOS_OS),Darwin) +#ifeq ($(KOKKOS_OS),Darwin) # If using Homebrew on OSX with the 'coreutils' package installed # we have a gnu version of cp which has the -u option - ifeq (,$(wildcard "/usr/local/opt/coreutils/libexec/gnubin/cp")) - CP = /usr/local/opt/coreutils/libexec/gnubin/cp - COPY_FLAG = -u - else - COPY_FLAG = - endif -endif +# ifeq (,$(wildcard "/usr/local/opt/coreutils/libexec/gnubin/cp")) +# CP = /usr/local/opt/coreutils/libexec/gnubin/cp +# COPY_FLAG = -u +# else +# COPY_FLAG = +# endif +#endif KOKKOSKERNELS_INTERNAL_SRC_BLAS_NODIR = $(notdir $(KOKKOSKERNELS_INTERNAL_SRC_BLAS)) KOKKOSKERNELS_INTERNAL_SRC_SPARSE_NODIR = $(notdir $(KOKKOSKERNELS_INTERNAL_SRC_SPARSE)) diff --git a/example/fenl/CGSolve.hpp b/example/fenl/CGSolve.hpp index 5fac00d343..dddf847c42 100644 --- a/example/fenl/CGSolve.hpp +++ b/example/fenl/CGSolve.hpp @@ -122,7 +122,7 @@ struct CGSolve< ImportType , SparseMatrixType , VectorType , timer.reset(); /* import p */ import( pAll ); /* Ap = A * p */ KokkosSparse::spmv( "N", 1.0, A , pAll, 0.0, Ap); - execution_space::fence(); + execution_space().fence(); matvec_time += timer.seconds(); const double pAp_dot = Kokkos::Example::all_reduce( KokkosBlas::dot( p , Ap ) , import.comm ); @@ -141,7 +141,7 @@ struct CGSolve< ImportType , SparseMatrixType , VectorType , ++iteration ; } - execution_space::fence(); + execution_space().fence(); iter_time = wall_clock.seconds(); } }; diff --git a/example/fenl/VectorImport.hpp b/example/fenl/VectorImport.hpp index f9a58637ac..3fec48de05 100644 --- a/example/fenl/VectorImport.hpp +++ b/example/fenl/VectorImport.hpp @@ -153,7 +153,7 @@ class VectorImport { , buffer( arg_buffer ) { Kokkos::parallel_for( "kokkos-kernels/example/fenl: Pack", index.extent(0) , *this ); - execution_space::fence(); + execution_space().fence(); } }; diff --git a/example/fenl/fenl_functors.hpp b/example/fenl/fenl_functors.hpp index 07a894f0fd..c391229f31 100644 --- a/example/fenl/fenl_functors.hpp +++ b/example/fenl/fenl_functors.hpp @@ -151,7 +151,7 @@ class NodeNodeGraph { Kokkos::parallel_for( "kokkos-kernels/example/fenl: NodeNodeGraph" , elem_node_id.extent(0) , *this ); } - execution_space::fence(); + execution_space().fence(); results.ratio = (double)node_node_set.size() / (double)node_node_set.span(); results.fill_node_set = wall_clock.seconds(); //-------------------------------- @@ -178,14 +178,14 @@ class NodeNodeGraph { //-------------------------------- // Fill graph's entries from the (node,node) set. - execution_space::fence(); + execution_space().fence(); results.scan_node_count = wall_clock.seconds(); wall_clock.reset(); phase = FILL_GRAPH_ENTRIES ; Kokkos::parallel_for( node_node_set.span() , *this ); - execution_space::fence(); + execution_space().fence(); results.fill_graph_entries = wall_clock.seconds(); //-------------------------------- @@ -202,7 +202,7 @@ class NodeNodeGraph { Kokkos::parallel_for( node_count , *this ); - execution_space::fence(); + execution_space().fence(); results.sort_graph_entries = wall_clock.seconds(); //-------------------------------- @@ -212,7 +212,7 @@ class NodeNodeGraph { elem_graph = ElemGraphType("elem_graph", elem_node_id.extent(0) ); Kokkos::parallel_for( elem_node_id.extent(0) , *this ); - execution_space::fence(); + execution_space().fence(); results.fill_element_graph = wall_clock.seconds(); } @@ -502,7 +502,7 @@ class NodeElemGatherFill { Kokkos::deep_copy( row_count , 0u ); Kokkos::parallel_for( elem_node_id.extent(0) , *this ); - execution_space::fence(); + execution_space().fence(); //-------------------------------- // Done with the temporary sets and arrays @@ -516,7 +516,7 @@ class NodeElemGatherFill { phase = SORT_GRAPH_ENTRIES ; Kokkos::parallel_for( residual.extent(0) , *this ); - execution_space::fence(); + execution_space().fence(); phase = GATHER_FILL ; } diff --git a/example/fenl/fenl_impl.hpp b/example/fenl/fenl_impl.hpp index f0dab0aa8e..daece01d43 100644 --- a/example/fenl/fenl_impl.hpp +++ b/example/fenl/fenl_impl.hpp @@ -347,7 +347,7 @@ Perf fenl( SparseMatrixType jacobian( "jacobian" , mesh_to_graph.graph ); - Device::fence(); + Device().fence(); perf.create_sparse_matrix = maximum( comm , wall_clock.seconds() ); @@ -444,7 +444,7 @@ Perf fenl( gatherfill.apply(); } - Device::fence(); + Device().fence(); perf.fill_time = maximum( comm , wall_clock.seconds() ); //-------------------------------- @@ -454,7 +454,7 @@ Perf fenl( dirichlet.apply(); - Device::fence(); + Device().fence(); perf.bc_time = maximum( comm , wall_clock.seconds() ); //-------------------------------- diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp b/perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp index 1fc58a37a3..d9bda101dd 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp @@ -124,7 +124,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmHost::CblasOpenMP", @@ -155,7 +155,7 @@ namespace KokkosBatched { }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -215,7 +215,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); if (std::is_same::value) { @@ -242,7 +242,7 @@ namespace KokkosBatched { 1, size_per_grp); } - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -297,7 +297,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat_simd); Kokkos::deep_copy(c, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); if (std::is_same::value) { @@ -322,7 +322,7 @@ namespace KokkosBatched { format, N*VectorLength); } - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -381,7 +381,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmHost::libxswmmOpenMP", @@ -402,7 +402,7 @@ namespace KokkosBatched { (double*)cc.data(), (const libxsmm_blasint*)&ldc); }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -451,7 +451,7 @@ namespace KokkosBatched { // Kokkos::deep_copy(b, bmat); // Kokkos::deep_copy(c, 0); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // timer.reset(); // Kokkos::parallel_for @@ -465,7 +465,7 @@ namespace KokkosBatched { // invoke(1.0, aa, bb, 1.0, cc); // }); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // const double t = timer.seconds(); // tmin = std::min(tmin, t); // tavg += (iter >= 0)*t; @@ -511,7 +511,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat_simd); Kokkos::deep_copy(c, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmHost::SIMDSerialOpenMP", @@ -525,7 +525,7 @@ namespace KokkosBatched { invoke(1.0, aa, bb, 1.0, cc); }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp b/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp index b22e65769d..cce509fcca 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp @@ -110,7 +110,7 @@ namespace KokkosBatched { Kokkos::deep_copy(x, xvec); Kokkos::deep_copy(y, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemvHost::CblasOpenMP", @@ -131,7 +131,7 @@ namespace KokkosBatched { } }); - HostSpaceType::fence(); + HostSpaceType().fence(); t += (iter >= 0)*timer.seconds(); } t /= iter_end; @@ -170,7 +170,7 @@ namespace KokkosBatched { Kokkos::deep_copy(x, xvec); Kokkos::deep_copy(y, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemvHost::SerialOpenMP", @@ -187,7 +187,7 @@ namespace KokkosBatched { } }); - HostSpaceType::fence(); + HostSpaceType().fence(); t += (iter >= 0)*timer.seconds(); } t /= iter_end; @@ -245,7 +245,7 @@ namespace KokkosBatched { Kokkos::deep_copy(x, xvec_simd); Kokkos::deep_copy(y, 0); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemvHost::SIMDSerialOpenMP", @@ -262,7 +262,7 @@ namespace KokkosBatched { } }); - HostSpaceType::fence(); + HostSpaceType().fence(); t += (iter >= 0)*timer.seconds(); } t /= iter_end; diff --git a/perf_test/batched/KokkosBatched_Test_LU_Host.hpp b/perf_test/batched/KokkosBatched_Test_LU_Host.hpp index 34371f2a98..8585c858a2 100644 --- a/perf_test/batched/KokkosBatched_Test_LU_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_LU_Host.hpp @@ -131,7 +131,7 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::RangePolicy policy(0, N*VectorLength); @@ -146,7 +146,7 @@ namespace KokkosBatched { (int*)pp.data()); }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -187,7 +187,7 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat_simd); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); mkl_dgetrfnp_compact(MKL_ROW_MAJOR, @@ -195,7 +195,7 @@ namespace KokkosBatched { (double*)a.data(), a.stride_1(), (MKL_INT*)&info, format, (MKL_INT)N*VectorLength); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -238,7 +238,7 @@ namespace KokkosBatched { // // initialize matrix // Kokkos::deep_copy(a, amat); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // timer.reset(); // Kokkos::RangePolicy policy(0, N*VectorLength); @@ -250,7 +250,7 @@ namespace KokkosBatched { // SerialLU::invoke(aa); // }); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // const double t = timer.seconds(); // tmin = std::min(tmin, t); // tavg += (iter >= 0)*t; @@ -290,7 +290,7 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat_simd); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::RangePolicy policy(0, N); @@ -302,7 +302,7 @@ namespace KokkosBatched { SerialLU::invoke(aa); }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp b/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp index 6df2391b00..94acc20543 100644 --- a/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp +++ b/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp @@ -148,7 +148,7 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::RangePolicy policy(0, N*VectorLength); @@ -201,7 +201,7 @@ namespace KokkosBatched { } }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -261,7 +261,7 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); switch (test) { @@ -342,7 +342,7 @@ namespace KokkosBatched { } } - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -391,7 +391,7 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat_simd); Kokkos::deep_copy(b, bmat_simd); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); switch (test) { @@ -472,7 +472,7 @@ namespace KokkosBatched { } } - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -518,7 +518,7 @@ namespace KokkosBatched { // Kokkos::deep_copy(a, amat); // Kokkos::deep_copy(b, bmat); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // timer.reset(); // Kokkos::RangePolicy policy(0, N*VectorLength); @@ -552,7 +552,7 @@ namespace KokkosBatched { // } // }); - // HostSpaceType::fence(); + // HostSpaceType().fence(); // const double t = timer.seconds(); // tmin = std::min(tmin, t); // tavg += (iter >= 0)*t; @@ -594,7 +594,7 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat_simd); Kokkos::deep_copy(b, bmat_simd); - HostSpaceType::fence(); + HostSpaceType().fence(); timer.reset(); Kokkos::RangePolicy policy(0, N); @@ -628,7 +628,7 @@ namespace KokkosBatched { } }); - HostSpaceType::fence(); + HostSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/graph/KokkosGraph_run_triangle.hpp b/perf_test/graph/KokkosGraph_run_triangle.hpp index 49339a4663..4384623b69 100644 --- a/perf_test/graph/KokkosGraph_run_triangle.hpp +++ b/perf_test/graph/KokkosGraph_run_triangle.hpp @@ -152,7 +152,7 @@ struct Flush { void run() { double sum = 0; Kokkos::parallel_reduce("KokkosGraph::PerfTest::Flush", Kokkos::RangePolicy(0,BufSize/sizeof(double)), *this, sum); - SpaceType::fence(); + SpaceType().fence(); std::cout << "Flush sum:" << sum << std::endl; FILE *fp = fopen("/dev/null", "w"); fprintf(fp, "%f\n", sum); @@ -341,7 +341,7 @@ void run_experiment( size_t num_triangles = 0; KokkosKernels::Impl::kk_reduce_view< Kokkos::View , ExecSpace>(rowmap_size, row_mapC, num_triangles); - ExecSpace::fence(); + ExecSpace().fence(); symbolic_time = timer1.seconds(); std::cout << "num_triangles:" << num_triangles << std::endl; diff --git a/perf_test/sparse/KokkosSparse_pcg.hpp b/perf_test/sparse/KokkosSparse_pcg.hpp index e7c6ef6eec..90b0895478 100644 --- a/perf_test/sparse/KokkosSparse_pcg.hpp +++ b/perf_test/sparse/KokkosSparse_pcg.hpp @@ -151,7 +151,7 @@ void block_pcgsolve( gauss_seidel_numeric (&kh, count_total, count_total, point_crsMat.graph.row_map, point_crsMat.graph.entries, point_crsMat.values); - Space::fence(); + Space().fence(); timer.reset(); */ @@ -162,7 +162,7 @@ void block_pcgsolve( precond_init_time += timer.seconds(); z = y_vector_t( "pcg::z" , count_total ); - Space::fence(); + Space().fence(); timer.reset(); symmetric_block_gauss_seidel_apply (&block_kh, _block_crsMat.numRows(), _block_crsMat.numCols(),block_size, _block_crsMat.graph.row_map, _block_crsMat.graph.entries, _block_crsMat.values, @@ -171,7 +171,7 @@ void block_pcgsolve( symmetric_gauss_seidel_apply (&kh, count_total, count_total, point_crsMat.graph.row_map, point_crsMat.graph.entries, point_crsMat.values, z, r, true, true, apply_count); */ - Space::fence(); + Space().fence(); precond_time += timer.seconds(); precond_old_rdot = KokkosBlas::dot( r , z ); Kokkos::deep_copy( p , z ); @@ -191,7 +191,7 @@ void block_pcgsolve( /* Ap = A * p */ KokkosSparse::spmv("N", 1, point_crsMat, pAll, 0, Ap); - Space::fence(); + Space().fence(); matvec_time += timer.seconds(); //const double pAp_dot = Kokkos::Example::all_reduce( dot( count_owned , p , Ap ) , import.comm ); @@ -218,7 +218,7 @@ void block_pcgsolve( double precond_r_dot = 1; double precond_beta = 1; if (use_sgs){ - Space::fence(); + Space().fence(); timer.reset(); symmetric_block_gauss_seidel_apply (&block_kh, _block_crsMat.numRows(), _block_crsMat.numCols(),block_size, _block_crsMat.graph.row_map, _block_crsMat.graph.entries, _block_crsMat.values, @@ -234,7 +234,7 @@ void block_pcgsolve( apply_count); */ - Space::fence(); + Space().fence(); precond_time += timer.seconds(); precond_r_dot = KokkosBlas::dot(r , z ); precond_beta = precond_r_dot / precond_old_rdot ; @@ -267,7 +267,7 @@ void block_pcgsolve( ++iteration ; } - Space::fence(); + Space().fence(); iter_time = wall_clock.seconds(); if ( 0 != result ) { @@ -358,17 +358,17 @@ void pcgsolve( gauss_seidel_numeric (&kh, count_total, count_total, crsMat.graph.row_map, crsMat.graph.entries, crsMat.values); - Space::fence(); + Space().fence(); precond_init_time += timer.seconds(); z = y_vector_t( "pcg::z" , count_total ); - Space::fence(); + Space().fence(); timer.reset(); symmetric_gauss_seidel_apply (&kh, count_total, count_total, crsMat.graph.row_map, crsMat.graph.entries, crsMat.values, z, r, true, true, apply_count); - Space::fence(); + Space().fence(); precond_time += timer.seconds(); precond_old_rdot = KokkosBlas::dot( r , z ); Kokkos::deep_copy( p , z ); @@ -388,7 +388,7 @@ void pcgsolve( /* Ap = A * p */ KokkosSparse::spmv("N", 1, crsMat, pAll, 0, Ap); - Space::fence(); + Space().fence(); matvec_time += timer.seconds(); //const double pAp_dot = Kokkos::Example::all_reduce( dot( count_owned , p , Ap ) , import.comm ); @@ -415,7 +415,7 @@ void pcgsolve( double precond_r_dot = 1; double precond_beta = 1; if (use_sgs){ - Space::fence(); + Space().fence(); timer.reset(); symmetric_gauss_seidel_apply( &kh, @@ -425,7 +425,7 @@ void pcgsolve( crsMat.values, z, r, true, apply_count); - Space::fence(); + Space().fence(); precond_time += timer.seconds(); precond_r_dot = KokkosBlas::dot(r , z ); precond_beta = precond_r_dot / precond_old_rdot ; @@ -458,7 +458,7 @@ void pcgsolve( ++iteration ; } - Space::fence(); + Space().fence(); iter_time = wall_clock.seconds(); if ( 0 != result ) { diff --git a/perf_test/sparse/KokkosSparse_run_spgemm.hpp b/perf_test/sparse/KokkosSparse_run_spgemm.hpp index 6f72596593..4da845b8d0 100644 --- a/perf_test/sparse/KokkosSparse_run_spgemm.hpp +++ b/perf_test/sparse/KokkosSparse_run_spgemm.hpp @@ -256,7 +256,7 @@ crsMat_t3 run_experiment( row_mapC_ref ); - ExecSpace::fence(); + ExecSpace().fence(); size_type c_nnz_size = sequential_kh.get_spgemm_handle()->get_c_nnz(); @@ -283,7 +283,7 @@ crsMat_t3 run_experiment( entriesC_ref, valuesC_ref ); - ExecSpace::fence(); + ExecSpace().fence(); typename crsMat_t3::HostMirror::StaticCrsGraphType static_graph (entriesC_ref, row_mapC_ref); typename crsMat_t3::HostMirror Ccrsmat("CrsMatrixC", k, valuesC_ref, static_graph); @@ -337,7 +337,7 @@ crsMat_t3 run_experiment( row_mapC ); - ExecSpace::fence(); + ExecSpace().fence(); double symbolic_time = timer1.seconds(); Kokkos::Impl::Timer timer3; @@ -366,7 +366,7 @@ crsMat_t3 run_experiment( entriesC, valuesC ); - ExecSpace::fence(); + ExecSpace().fence(); double numeric_time = timer3.seconds(); std::cout diff --git a/src/batched/KokkosBatched_Util.hpp b/src/batched/KokkosBatched_Util.hpp index cf913ab0f1..b80af089f3 100644 --- a/src/batched/KokkosBatched_Util.hpp +++ b/src/batched/KokkosBatched_Util.hpp @@ -140,7 +140,7 @@ namespace KokkosBatched { void run() { double sum = 0; Kokkos::parallel_reduce(Kokkos::RangePolicy(0,BufSize/sizeof(double)), *this, sum); - SpaceType::fence(); + SpaceType().fence(); FILE *fp = fopen("/dev/null", "w"); fprintf(fp, "%f\n", sum); fclose(fp); diff --git a/src/common/KokkosKernels_PrintUtils.hpp b/src/common/KokkosKernels_PrintUtils.hpp index 6d1574b2ff..7fb8f58940 100644 --- a/src/common/KokkosKernels_PrintUtils.hpp +++ b/src/common/KokkosKernels_PrintUtils.hpp @@ -86,7 +86,7 @@ inline void kk_get_histogram( out_lno_view_t histogram /*must be initialized with 0s*/){ typedef Kokkos::RangePolicy my_exec_space; Kokkos::parallel_for( "KokkosKernels::Common::GetHistogram", my_exec_space(0, in_elements), Histogram(in_view, histogram)); - MyExecSpace::fence(); + MyExecSpace().fence(); } /** diff --git a/src/common/KokkosKernels_SimpleUtils.hpp b/src/common/KokkosKernels_SimpleUtils.hpp index 7ca1ae22f4..f24e40887d 100644 --- a/src/common/KokkosKernels_SimpleUtils.hpp +++ b/src/common/KokkosKernels_SimpleUtils.hpp @@ -250,7 +250,7 @@ bool kk_is_identical_view(view_type1 view1, view_type2 view2, eps_type eps){ size_t issame = 0; Kokkos::parallel_reduce( "KokkosKernels::Common::IsIdenticalView", my_exec_space(0,num_elements), IsIdenticalFunctor(view1, view2, eps), issame); - MyExecSpace::fence(); + MyExecSpace().fence(); if (issame > 0){ return false; } diff --git a/src/common/KokkosKernels_SparseUtils.hpp b/src/common/KokkosKernels_SparseUtils.hpp index ab0df8ae63..d0e72e816d 100644 --- a/src/common/KokkosKernels_SparseUtils.hpp +++ b/src/common/KokkosKernels_SparseUtils.hpp @@ -496,13 +496,13 @@ inline void kk_transpose_graph( else { Kokkos::parallel_for( "KokkosKernels::Common::TransposeGraph::StaticSchedule::S0", count_tp_t(num_rows / team_work_chunk_size + 1 , suggested_team_size, vector_size), tm); } - MyExecSpace::fence(); + MyExecSpace().fence(); kk_exclusive_parallel_prefix_sum(num_cols+1, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::deep_copy(tmp_row_view, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); if (use_dynamic_scheduling){ @@ -511,7 +511,7 @@ inline void kk_transpose_graph( else { Kokkos::parallel_for( "KokkosKernels::Common::TransposeGraph::StaticSchedule::S1", d_fill_tp_t(num_rows / team_work_chunk_size + 1 , suggested_team_size, vector_size), tm); } - MyExecSpace::fence(); + MyExecSpace().fence(); } template @@ -684,21 +684,21 @@ void kk_create_reverse_map( multiply_shift_for_scale, division_shift_for_bucket); Kokkos::parallel_for ("KokkosKernels::Common::CreateReverseMap::NonAtomic::S0", my_cnt_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); //kk_inclusive_parallel_prefix_sum(tmp_reverse_size + 1, tmp_color_xadj); kk_exclusive_parallel_prefix_sum (tmp_reverse_size + 1, tmp_color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::parallel_for ("KokkosKernels::Common::CreateReverseMap::NonAtomic::S1", my_exec_space (0, num_reverse_elements + 1) , StridedCopy1 (tmp_color_xadj, reverse_map_xadj, scale_size)); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::parallel_for ("KokkosKernels::Common::CreateReverseMap::NonAtomic::S2",my_fill_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); } else //atomic implementation. @@ -714,18 +714,18 @@ void kk_create_reverse_map( rmp_functor_type frm (forward_map, tmp_color_xadj, reverse_map_adj); Kokkos::parallel_for ("KokkosKernels::Common::CreateReverseMap::Atomic::S0", my_cnt_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); //kk_inclusive_parallel_prefix_sum(num_reverse_elements + 1, reverse_map_xadj); kk_exclusive_parallel_prefix_sum (num_reverse_elements + 1, tmp_color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::deep_copy (reverse_map_xadj, tmp_color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::parallel_for ("KokkosKernels::Common::CreateReverseMap::Atomic::S1", my_fill_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); } } @@ -826,7 +826,7 @@ inline size_t kk_is_d1_coloring_valid( Kokkos::parallel_reduce( "KokkosKernels::Common::IsD1ColoringValie", dynamic_team_policy(num_rows / team_work_chunk_size + 1 , suggested_team_size, vector_size), cc, num_conf); - MyExecSpace::fence(); + MyExecSpace().fence(); return num_conf; } @@ -854,7 +854,7 @@ void kk_sort_graph( Kokkos::deep_copy (he, in_adj); typename scalar_view_t::HostMirror hv = Kokkos::create_mirror_view (in_vals); Kokkos::deep_copy (hv, in_vals); - MyExecSpace::fence(); + MyExecSpace().fence(); typename lno_nnz_view_t::HostMirror heo = Kokkos::create_mirror_view (out_adj); typename scalar_view_t::HostMirror hvo = Kokkos::create_mirror_view (out_vals); @@ -885,7 +885,7 @@ void kk_sort_graph( Kokkos::deep_copy (out_adj, heo); Kokkos::deep_copy (out_vals, hvo); - MyExecSpace::fence(); + MyExecSpace().fence(); } else { @@ -1058,7 +1058,7 @@ inline void kk_create_incidence_matrix( else { Kokkos::parallel_for( d_fill_tp_t(num_rows / team_work_chunk_size + 1 , suggested_team_size, vector_size), tm); } - MyExecSpace::fence(); + MyExecSpace().fence(); } */ @@ -1293,7 +1293,7 @@ void kk_get_lower_triangle_count_parallel( else { Kokkos::parallel_for( "KokkosKernels::Common::GetLowerTriangleCount::StaticSchedule", count_tp_t(nv / team_work_chunk_size + 1 , suggested_team_size, vector_size), ltm); } - ExecutionSpace::fence(); + ExecutionSpace().fence(); } @@ -1480,7 +1480,7 @@ void kk_get_lower_triangle_fill_parallel( else { Kokkos::parallel_for( "KokkosKernels::Common::GetLowerTriangleFill::StaticSchedule", fill_p_t(nv / team_work_chunk_size + 1 , suggested_team_size, vector_size), ltm); } - ExecutionSpace::fence(); + ExecutionSpace().fence(); } template void kk_get_lower_triangle_fill_sequential( @@ -1618,7 +1618,7 @@ crstmat_t kk_get_lower_triangle(crstmat_t in_crs_matrix, kk_exclusive_parallel_prefix_sum (nr + 1, new_row_map); - exec_space::fence(); + exec_space().fence(); auto ll_size = Kokkos::subview(new_row_map, nr); auto h_ll_size = Kokkos::create_mirror_view (ll_size); @@ -1675,7 +1675,7 @@ crstmat_t kk_get_lower_crs_matrix(crstmat_t in_crs_matrix, kk_exclusive_parallel_prefix_sum (nr + 1, new_row_map); - exec_space::fence(); + exec_space().fence(); auto ll_size = Kokkos::subview(new_row_map, nr); auto h_ll_size = Kokkos::create_mirror_view (ll_size); @@ -1729,7 +1729,7 @@ graph_t kk_get_lower_crs_graph(graph_t in_crs_matrix, kk_exclusive_parallel_prefix_sum (nr + 1, new_row_map); - exec_space::fence(); + exec_space().fence(); auto ll_size = Kokkos::subview(new_row_map, nr); auto h_ll_size = Kokkos::create_mirror_view (ll_size); @@ -1797,7 +1797,7 @@ void kk_get_lower_triangle( kk_exclusive_parallel_prefix_sum (nr + 1, out_rowmap); - exec_space::fence(); + exec_space().fence(); auto ll_size = Kokkos::subview(out_rowmap, nr); auto h_ll_size = Kokkos::create_mirror_view (ll_size); @@ -1914,10 +1914,10 @@ void kk_create_incidence_matrix_from_lower_triangle( Kokkos::atomic_fetch_add(&(out_rowmap[in_lower_entries[i]]), atomic_incr_type(1)); }); - exec_space::fence(); + exec_space().fence(); kk_exclusive_parallel_prefix_sum(nr+1, out_rowmap); - exec_space::fence(); + exec_space().fence(); Kokkos::parallel_for("KokkosKernels::Common::CreateIncidenceTransposeMatrixFromLowerTriangle::S0", my_exec_space(0, nr + 1), KOKKOS_LAMBDA(const lno_t& i) { out_rowmap[i] += in_lower_rowmap[i]; @@ -1944,7 +1944,7 @@ void kk_create_incidence_matrix_from_lower_triangle( out_entries[out_begin + i] = edge_ind; } }); - exec_space::fence(); + exec_space().fence(); Kokkos::parallel_for("KokkosKernels::Common::CreateIncidenceTransposeMatrixFromLowerTriangle::S2", my_exec_space(0, ne), KOKKOS_LAMBDA(const size_type& edge_ind) { lno_t col = in_lower_entries[edge_ind]; @@ -2010,7 +2010,7 @@ void kk_create_incidence_matrix_from_original_matrix( permutation.data(), use_dynamic_scheduling, chunksize, sort_decreasing_order); - exec_space::fence(); + exec_space().fence(); kk_exclusive_parallel_prefix_sum(nr+1, out_rowmap); //kk_print_1Dview(out_rowmap, false, 20); diff --git a/src/common/KokkosKernels_Utils.hpp b/src/common/KokkosKernels_Utils.hpp index 406e67090f..d0078a0119 100644 --- a/src/common/KokkosKernels_Utils.hpp +++ b/src/common/KokkosKernels_Utils.hpp @@ -886,18 +886,18 @@ void create_reverse_map( multiply_shift_for_scale, division_shift_for_bucket); Kokkos::parallel_for ("KokkosKernels::Common::ReverseMapScaleInit",my_exec_space (0, num_forward_elements) , rmi); - MyExecSpace::fence(); + MyExecSpace().fence(); inclusive_parallel_prefix_sum(tmp_reverse_size + 1, tmp_color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::parallel_for ("KokkosKernels::Common::StridedCopy",my_exec_space (0, num_reverse_elements + 1) , StridedCopy(tmp_color_xadj, reverse_map_xadj, scale_size)); - MyExecSpace::fence(); + MyExecSpace().fence(); Fill_Reverse_Scale_Map frm (forward_map, tmp_color_xadj, reverse_map_adj, multiply_shift_for_scale, division_shift_for_bucket); Kokkos::parallel_for ("KokkosKernels::Common::FillReverseMap",my_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); } else //atomic implementation. @@ -907,17 +907,17 @@ void create_reverse_map( Reverse_Map_Init rmi(forward_map, reverse_map_xadj); Kokkos::parallel_for ("KokkosKernels::Common::ReverseMapInit",my_exec_space (0, num_forward_elements) , rmi); - MyExecSpace::fence(); + MyExecSpace().fence(); //print_1Dview(reverse_map_xadj); inclusive_parallel_prefix_sum(num_reverse_elements + 1, reverse_map_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::deep_copy (tmp_color_xadj, reverse_map_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Fill_Reverse_Map frm (forward_map, tmp_color_xadj, reverse_map_adj); Kokkos::parallel_for ("KokkosKernels::Common::FillReverseMap",my_exec_space (0, num_forward_elements) , frm); - MyExecSpace::fence(); + MyExecSpace().fence(); } } @@ -1155,7 +1155,7 @@ void symmetrize_and_get_lower_diagonal_edge_list( Kokkos::parallel_for("KokkosKernels::Common::SymmetrizeAndGetLowerDiagonalEdgeList::S0", team_policy(num_rows_to_symmetrize / teamSizeMax + 1 , teamSizeMax, vector_size), fse/*, num_symmetric_edges*/); - MyExecSpace::fence(); + MyExecSpace().fence(); } @@ -1163,7 +1163,7 @@ void symmetrize_and_get_lower_diagonal_edge_list( exclusive_parallel_prefix_sum( num_rows_to_symmetrize + 1, pre_pps_); - MyExecSpace::fence(); + MyExecSpace().fence(); auto d_sym_edge_size = Kokkos::subview(pre_pps_, num_rows_to_symmetrize); auto h_sym_edge_size = Kokkos::create_mirror_view (d_sym_edge_size); @@ -1179,7 +1179,7 @@ void symmetrize_and_get_lower_diagonal_edge_list( sym_srcs = out_lno_nnz_view_t(Kokkos::ViewAllocateWithoutInitializing("sym_srcs"), num_symmetric_edges); sym_dsts_ = out_lno_nnz_view_t(Kokkos::ViewAllocateWithoutInitializing("sym_dsts_"), num_symmetric_edges); - MyExecSpace::fence(); + MyExecSpace().fence(); { hashmap_t umap (nnz); @@ -1214,10 +1214,10 @@ void symmetrize_and_get_lower_diagonal_edge_list( Kokkos::parallel_for("KokkosKernels::Common::SymmetrizeAndGetLowerDiagonalEdgeList::S1", team_policy(num_rows_to_symmetrize / teamSizeMax + 1 , teamSizeMax, vector_size), FSCH); - MyExecSpace::fence(); + MyExecSpace().fence(); } - MyExecSpace::fence(); + MyExecSpace().fence(); } @@ -1299,7 +1299,7 @@ void symmetrize_graph_symbolic_hashmap( Kokkos::parallel_for("KokkosKernels::Common::SymmetrizeGraphSymbolicHashMap::S0", team_policy(num_rows_to_symmetrize / teamSizeMax + 1 , teamSizeMax, vector_size), fse/*, num_symmetric_edges*/); - MyExecSpace::fence(); + MyExecSpace().fence(); } @@ -1307,7 +1307,7 @@ void symmetrize_graph_symbolic_hashmap( exclusive_parallel_prefix_sum( num_rows_to_symmetrize + 1, pre_pps_); - MyExecSpace::fence(); + MyExecSpace().fence(); //out_lno_row_view_t d_sym_edge_size = Kokkos::subview(pre_pps_, num_rows_to_symmetrize, num_rows_to_symmetrize ); @@ -1318,7 +1318,7 @@ void symmetrize_graph_symbolic_hashmap( sym_adj = out_lno_nnz_view_t(Kokkos::ViewAllocateWithoutInitializing("sym_adj"), num_symmetric_edges); - MyExecSpace::fence(); + MyExecSpace().fence(); sym_xadj = out_lno_row_view_t(Kokkos::ViewAllocateWithoutInitializing("sym_xadj"), num_rows_to_symmetrize + 1); Kokkos::deep_copy(sym_xadj, pre_pps_); { @@ -1355,10 +1355,10 @@ void symmetrize_graph_symbolic_hashmap( Kokkos::parallel_for("KokkosKernels::Common::SymmetrizeGraphSymbolicHashMap::S1", team_policy(num_rows_to_symmetrize / teamSizeMax + 1 , teamSizeMax, vector_size), FSCH); - MyExecSpace::fence(); + MyExecSpace().fence(); } - MyExecSpace::fence(); + MyExecSpace().fence(); } @@ -1605,7 +1605,7 @@ bool isSame(size_t num_elements, view_type1 view1, view_type2 view2){ typedef Kokkos::RangePolicy my_exec_space; int issame = 1; Kokkos::parallel_reduce( "KokkosKernels::Common::isSame", my_exec_space(0,num_elements), IsEqualFunctor(view1, view2), issame); - MyExecSpace::fence(); + MyExecSpace().fence(); return issame; } @@ -1773,16 +1773,16 @@ void transpose_matrix( Kokkos::Impl::Timer timer1; Kokkos::parallel_for( "KokkosKernels::Common::TransposeMatrix::S0", tcp_t(num_rows / team_row_work_size + 1 , Kokkos::AUTO_t(), vector_size), tm); - MyExecSpace::fence(); + MyExecSpace().fence(); exclusive_parallel_prefix_sum(num_cols+1, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::deep_copy(tmp_row_view, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); timer1.reset(); Kokkos::parallel_for( "KokkosKernels::Common::TransposeMatrix::S1", tfp_t(num_rows / team_row_work_size + 1 , Kokkos::AUTO_t(), vector_size), tm); - MyExecSpace::fence(); + MyExecSpace().fence(); } template (num_cols+1, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::deep_copy(tmp_row_view, t_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); timer1.reset(); Kokkos::parallel_for( "KokkosKernels::Common::TransposeGraph::S1", tfp_t(num_rows , Kokkos::AUTO_t(), vector_size), tm); - MyExecSpace::fence(); + MyExecSpace().fence(); } @@ -1913,7 +1913,7 @@ void init_view_withscalar(typename in_row_view_t::size_type num_elements, in_row Kokkos::Impl::Timer timer1; Kokkos::parallel_for( "KokkosKernels::Common::InitViewWithScalar", tcp_t(num_elements / chunk_size + 1 , team_size, vector_size), tm); - MyExecSpace::fence(); + MyExecSpace().fence(); } diff --git a/src/graph/KokkosGraph_Distance1ColorHandle.hpp b/src/graph/KokkosGraph_Distance1ColorHandle.hpp index 4d479be3d9..b7003d4a1a 100644 --- a/src/graph/KokkosGraph_Distance1ColorHandle.hpp +++ b/src/graph/KokkosGraph_Distance1ColorHandle.hpp @@ -538,7 +538,7 @@ class GraphColoringHandle KokkosKernels::Impl::inclusive_parallel_prefix_sum (nv+1, lower_count); //Kokkos::parallel_scan (my_exec_space(0, nv + 1), PPS(lower_count)); - HandleExecSpace::fence(); + HandleExecSpace().fence(); auto lower_total_count = Kokkos::subview(lower_count, nv); auto hlower = Kokkos::create_mirror_view (lower_total_count); Kokkos::deep_copy (hlower, lower_total_count); diff --git a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp index 76eeb8debe..7bbc2df505 100644 --- a/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance1Color_impl.hpp @@ -154,7 +154,7 @@ class GraphColor Kokkos::deep_copy (h_xadj, this->xadj); Kokkos::deep_copy (h_adj, this->adj); - MyExecSpace::fence(); + MyExecSpace().fence(); @@ -219,7 +219,7 @@ class GraphColor typename const_lno_nnz_view_t::HostMirror h_adj = Kokkos::create_mirror_view (this->adj); Kokkos::deep_copy (h_xadj, this->xadj); Kokkos::deep_copy (h_adj, this->adj); - MyExecSpace::fence(); + MyExecSpace().fence(); typedef typename col_view_t_::HostMirror col_host_view_t; //Host view type @@ -228,7 +228,7 @@ class GraphColor col_nnz_view_t h_c_adj = Kokkos::create_mirror_view (col_entries); Kokkos::deep_copy (h_c_xadj, col_map); Kokkos::deep_copy (h_c_adj, col_entries); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::Impl::Timer timer; @@ -304,7 +304,7 @@ class GraphColor typename const_lno_nnz_view_t::HostMirror h_adj = Kokkos::create_mirror_view (this->adj); Kokkos::deep_copy (h_xadj, this->xadj); Kokkos::deep_copy (h_adj, this->adj); - MyExecSpace::fence(); + MyExecSpace().fence(); //create a ban color array to keep track of //which colors have been taking by the neighbor vertices. @@ -544,7 +544,7 @@ class GraphColor2: public GraphColor adj); Kokkos::deep_copy (h_xadj, this->xadj); Kokkos::deep_copy (h_adj, this->adj); - MyExecSpace::fence(); + MyExecSpace().fence(); typedef typename col_view_t_::HostMirror col_host_view_t; //Host view type typedef typename lno_colnnz_view_t_::HostMirror col_nnz_view_t; //Host view type @@ -552,7 +552,7 @@ class GraphColor2: public GraphColor _ticToc){ t = timer.seconds(); @@ -1000,7 +1000,7 @@ class GraphColor_VB:public GraphColor (current_vertexList_, next_iteration_recolorList_, pps_work_view)); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::parallel_for ("KokkosGraph::GraphColoring::CreateNewWorkArray", my_exec_space(0, current_vertexListLength_), create_new_work_array(current_vertexList_, next_iteration_recolorList_, pps_work_view)); @@ -2925,7 +2925,7 @@ class GraphColor_EB:public GraphColor nv << " init_work_arrays" << std::endl; double inittime = 0; @@ -2961,7 +2961,7 @@ class GraphColor_EB:public GraphColor nv << " i:" << i << " halfedge_mark_conflicts" << std::endl; if (tictoc){ @@ -2985,7 +2985,7 @@ class GraphColor_EB:public GraphColor nv @@ -3020,13 +3020,13 @@ class GraphColor_EB:public GraphColor seconds(); diff --git a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp index aa3c7930ba..73cf290629 100644 --- a/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp +++ b/src/graph/impl/KokkosGraph_Distance2Color_impl.hpp @@ -312,7 +312,7 @@ class GraphColorDistance2 this->xadj, this->adj, this->t_xadj, this->t_adj, colors_out, current_vertexList, current_vertexListLength); } - my_exec_space::fence(); + my_exec_space().fence(); if(this->_ticToc) { @@ -345,7 +345,7 @@ class GraphColorDistance2 next_iteration_recolorList, next_iteration_recolorListLength); - my_exec_space::fence(); + my_exec_space().fence(); if(_ticToc) { @@ -393,7 +393,7 @@ class GraphColorDistance2 current_vertexListLength); } - my_exec_space::fence(); + my_exec_space().fence(); if(_ticToc) { @@ -485,7 +485,7 @@ class GraphColorDistance2 KokkosKernels::Impl::kk_get_histogram( this->nv, this->gc_handle->get_vertex_colors(), histogram); - my_exec_space::fence(); + my_exec_space().fence(); } diff --git a/src/sparse/KokkosSparse_spadd.hpp b/src/sparse/KokkosSparse_spadd.hpp index 5785541c45..be15ab5d99 100644 --- a/src/sparse/KokkosSparse_spadd.hpp +++ b/src/sparse/KokkosSparse_spadd.hpp @@ -436,11 +436,11 @@ namespace Experimental { SortedCountEntries countEntries(a_rowmap, a_entries, b_rowmap, b_entries, c_rowcounts); Kokkos::parallel_for("KokkosSparse::SpAdd::Symbolic::InputSorted::CountEntries", range_type(0, nrows), countEntries); - execution_space::fence(); + execution_space().fence(); //get c_rowmap as cumulative sum parallel_prefix_sum prefix(c_rowcounts, c_rowmap); Kokkos::parallel_scan("KokkosSparse::SpAdd:Symbolic::InputSorted::PrefixSum", range_type(0, nrows + 1), prefix); - execution_space::fence(); + execution_space().fence(); } else { @@ -453,17 +453,17 @@ namespace Experimental { UnsortedEntriesUpperBound countEntries(a_rowmap, b_rowmap, c_rowcounts_upperbound); Kokkos::parallel_for("KokkosSparse::SpAdd:Symbolic::InputNotSorted::CountEntires", range_type(0, nrows), countEntries); - execution_space::fence(); + execution_space().fence(); //get (temporary) c_rowmap as cumulative sum parallel_prefix_sum prefix(c_rowcounts_upperbound, c_rowmap_upperbound); Kokkos::parallel_scan("KokkosSparse::SpAdd:Symbolic::InputNotSorted::PrefixSum", range_type(0, nrows + 1), prefix); //compute uncompressed entries of C (just indices, no scalars) - execution_space::fence(); + execution_space().fence(); auto d_c_nnz_size = Kokkos::subview(c_rowmap_upperbound, nrows); auto h_c_nnz_size = Kokkos::create_mirror_view (d_c_nnz_size); Kokkos::deep_copy (h_c_nnz_size, d_c_nnz_size); - execution_space::fence(); + execution_space().fence(); c_nnz_upperbound = h_c_nnz_size(); } clno_nnz_view_t_ c_entries_uncompressed("C entries uncompressed", c_nnz_upperbound); @@ -473,12 +473,12 @@ namespace Experimental { alno_nnz_view_t_, blno_nnz_view_t_, clno_nnz_view_t_> unmergedSum( a_rowmap, a_entries, b_rowmap, b_entries, c_rowmap_upperbound, c_entries_uncompressed, ab_perm); Kokkos::parallel_for("KokkosSparse::SpAdd:Symbolic::InputNotSorted::UnmergedSum", range_type(0, nrows), unmergedSum); - execution_space::fence(); + execution_space().fence(); //sort the unmerged sum SortEntriesFunctor sortEntries(c_rowmap_upperbound, c_entries_uncompressed, ab_perm); Kokkos::parallel_for("KokkosSparse::SpAdd:Symbolic::InputNotSorted::SortEntries", range_type(0, nrows), sortEntries); - execution_space::fence(); + execution_space().fence(); clno_nnz_view_t_ a_pos("A entry positions", a_entries.extent(0)); clno_nnz_view_t_ b_pos("B entry positions", b_entries.extent(0)); //merge the entries and compute Apos/Bpos, as well as Crowcounts @@ -487,11 +487,11 @@ namespace Experimental { MergeEntriesFunctor mergeEntries(a_rowmap, b_rowmap, c_rowmap_upperbound, c_rowcounts, c_entries_uncompressed, ab_perm, a_pos, b_pos); Kokkos::parallel_for("KokkosSparse::SpAdd:Symbolic::InputNotSorted::MergeEntries", range_type(0, nrows), mergeEntries); - execution_space::fence(); + execution_space().fence(); //compute actual c_rowmap parallel_prefix_sum prefix(c_rowcounts, c_rowmap); Kokkos::parallel_scan("KokkosSparse::SpAdd:Symbolic::InputNotSorted::PrefixSumSecond", range_type(0, nrows + 1), prefix); - execution_space::fence(); + execution_space().fence(); } addHandle->set_a_b_pos(a_pos, b_pos); } @@ -501,7 +501,7 @@ namespace Experimental { auto d_c_nnz_size = Kokkos::subview(c_rowmap, nrows); auto h_c_nnz_size = Kokkos::create_mirror_view (d_c_nnz_size); Kokkos::deep_copy (h_c_nnz_size, d_c_nnz_size); - execution_space::fence(); + execution_space().fence(); size_type cmax = h_c_nnz_size(); addHandle->set_max_result_nnz(cmax); @@ -723,7 +723,7 @@ namespace Experimental { ascalar_t_, bscalar_t_> sortedNumeric(a_rowmap, b_rowmap, c_rowmap, a_entries, b_entries, c_entries, a_values, b_values, c_values, alpha, beta); Kokkos::parallel_for("KokkosSparse::SpAdd:Numeric::InputSorted", range_type(0, nrows), sortedNumeric); - execution_space::fence(); + execution_space().fence(); } else { @@ -734,7 +734,7 @@ namespace Experimental { ascalar_t_, bscalar_t_> unsortedNumeric(a_rowmap, b_rowmap, c_rowmap, a_entries, b_entries, c_entries, a_values, b_values, c_values, alpha, beta, addHandle->get_a_pos(), addHandle->get_b_pos()); Kokkos::parallel_for("KokkosSparse::SpAdd:Numeric::InputNotSorted", range_type(0, nrows), unsortedNumeric); - execution_space::fence(); + execution_space().fence(); } addHandle->set_call_numeric(); } diff --git a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp index 4b2c24ac8a..7a8128575b 100644 --- a/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp +++ b/src/sparse/impl/KokkosSparse_gauss_seidel_impl.hpp @@ -663,7 +663,7 @@ namespace KokkosSparse{ (num_rows, numColors, colors, color_xadj, color_adj); - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE @@ -673,7 +673,7 @@ namespace KokkosSparse{ nnz_lno_persistent_work_host_view_t h_color_xadj = Kokkos::create_mirror_view (color_xadj); Kokkos::deep_copy (h_color_xadj , color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE @@ -691,18 +691,18 @@ namespace KokkosSparse{ if (color_index_begin + 1 >= color_index_end ) continue; auto colorsubset = subview(color_adj, Kokkos::pair (color_index_begin, color_index_end)); - MyExecSpace::fence(); + MyExecSpace().fence(); Kokkos::sort (colorsubset); //TODO: MD 08/2017: If I remove the below fence, code fails on cuda. //I do not see any reason yet it to fail. - MyExecSpace::fence(); + MyExecSpace().fence(); } } #endif - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE std::cout << "SORT_TIME:" << timer.seconds() << std::endl; timer.reset(); @@ -720,7 +720,7 @@ namespace KokkosSparse{ permuted_xadj, old_to_new_map)); //std::cout << "create_permuted_xadj" << std::endl; - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE std::cout << "CREATE_PERMUTED_XADJ:" << timer.seconds() << std::endl; @@ -732,7 +732,7 @@ namespace KokkosSparse{ KokkosKernels::Impl::inclusive_parallel_prefix_sum (num_rows + 1, permuted_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE std::cout << "INCLUSIVE_PPS:" << timer.seconds() << std::endl; @@ -751,7 +751,7 @@ namespace KokkosSparse{ permuted_adj, //newvals_, old_to_new_map)); - MyExecSpace::fence(); + MyExecSpace().fence(); #ifdef KOKKOSSPARSE_IMPL_TIME_REVERSE std::cout << "SYMBOLIC_FILL:" << timer.seconds() << std::endl; @@ -1163,7 +1163,7 @@ namespace KokkosSparse{ block_matrix_size )); } - MyExecSpace::fence(); + MyExecSpace().fence(); gsHandler->set_new_adj_val(permuted_adj_vals); scalar_persistent_work_view_t permuted_inverse_diagonal (Kokkos::ViewAllocateWithoutInitializing("permuted_inverse_diagonal"), num_rows * block_size ); @@ -1210,7 +1210,7 @@ namespace KokkosSparse{ } - MyExecSpace::fence(); + MyExecSpace().fence(); this->handle->get_gs_handle()->set_permuted_inverse_diagonal(permuted_inverse_diagonal); this->handle->get_gs_handle()->set_call_numeric(true); @@ -1268,7 +1268,7 @@ namespace KokkosSparse{ Permuted_Yvector ); } - MyExecSpace::fence(); + MyExecSpace().fence(); if(init_zero_x_vector){ KokkosKernels::Impl::zero_vector(num_cols * block_size, Permuted_Xvector); } @@ -1281,7 +1281,7 @@ namespace KokkosSparse{ Permuted_Xvector ); } - MyExecSpace::fence(); + MyExecSpace().fence(); @@ -1358,7 +1358,7 @@ namespace KokkosSparse{ Permuted_Xvector, x_lhs_output_vec ); - MyExecSpace::fence(); + MyExecSpace().fence(); #if KOKKOSSPARSE_IMPL_PRINTDEBUG std::cout << "After X:"; @@ -1408,7 +1408,7 @@ namespace KokkosSparse{ Permuted_Yvector ); } - MyExecSpace::fence(); + MyExecSpace().fence(); if(init_zero_x_vector){ KokkosKernels::Impl::zero_vector(num_cols, Permuted_Xvector); } @@ -1421,7 +1421,7 @@ namespace KokkosSparse{ Permuted_Xvector ); } - MyExecSpace::fence(); + MyExecSpace().fence(); row_lno_persistent_work_view_t permuted_xadj = gsHandler->get_new_xadj(); nnz_lno_persistent_work_view_t permuted_adj = gsHandler->get_new_adj(); @@ -1476,7 +1476,7 @@ namespace KokkosSparse{ Permuted_Xvector, x_lhs_output_vec ); - MyExecSpace::fence(); + MyExecSpace().fence(); #if KOKKOSSPARSE_IMPL_PRINTDEBUG std::cout << "--point After X:"; KokkosKernels::Impl::print_1Dview(Permuted_Xvector); @@ -1576,7 +1576,7 @@ namespace KokkosSparse{ gs ); } - MyExecSpace::fence(); + MyExecSpace().fence(); } } if (apply_backward){ @@ -1608,7 +1608,7 @@ namespace KokkosSparse{ bigblock_team_fill_policy_t(numberOfTeams / team_row_chunk_size + 1 , suggested_team_size, vector_size), gs ); } - MyExecSpace::fence(); + MyExecSpace().fence(); if (i == 0){ break; } @@ -1643,7 +1643,7 @@ namespace KokkosSparse{ //std::cout << "i:" << i << " color_index_begin:" << color_index_begin << " color_index_end:" << color_index_end << std::endl; Kokkos::parallel_for ("KokkosSparse::GaussSeidel::PSGS::forward", my_exec_space (color_index_begin, color_index_end) , gs); - MyExecSpace::fence(); + MyExecSpace().fence(); } } if (apply_backward && numColors){ @@ -1652,7 +1652,7 @@ namespace KokkosSparse{ nnz_lno_t color_index_end = h_color_xadj(i + 1); Kokkos::parallel_for ("KokkosSparse::GaussSeidel::PSGS::backward", my_exec_space (color_index_begin, color_index_end) , gs); - MyExecSpace::fence(); + MyExecSpace().fence(); if (i == 0){ break; } diff --git a/src/sparse/impl/KokkosSparse_spgemm_CUSP_impl.hpp b/src/sparse/impl/KokkosSparse_spgemm_CUSP_impl.hpp index c5547f00f7..c7242c9730 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_CUSP_impl.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_CUSP_impl.hpp @@ -182,7 +182,7 @@ void CUSP_apply( Kokkos::Impl::Timer timer1; cusp::multiply(A,B,C); - KernelHandle::HandleExecSpace::fence(); + KernelHandle::HandleExecSpace().fence(); std::cout << "Actual CUSP SPMM Time:" << timer1.seconds() << std::endl; diff --git a/src/sparse/impl/KokkosSparse_spgemm_imp_outer.hpp b/src/sparse/impl/KokkosSparse_spgemm_imp_outer.hpp index 16d3d39dae..dbf3c3f7dd 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_imp_outer.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_imp_outer.hpp @@ -617,7 +617,7 @@ void KokkosSPGEMM row_mapA, entriesA, valsA, transpose_col_xadj,transpose_col_adj, tranpose_vals); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tTranspose FlopsPerRowOuterCal BlockPartition FastAllocation"; std::cout << " Outer Sort Collapse CopyToSLOW MultiWayMerge FinalCollapse Overall"< fpr(b_row_cnt, transpose_col_xadj, row_mapB, flop_per_row); Kokkos::parallel_for(Kokkos::RangePolicy (0,b_row_cnt), fpr); - MyExecSpace::fence(); + MyExecSpace().fence(); KokkosKernels::Impl:: exclusive_parallel_prefix_sum @@ -651,7 +651,7 @@ void KokkosSPGEMM auto num_flops = Kokkos::subview(flop_per_row, b_row_cnt); auto h_num_flops = Kokkos::create_mirror_view (num_flops); Kokkos::deep_copy (h_num_flops, num_flops); - MyExecSpace::fence(); + MyExecSpace().fence(); size_t num_required_flops = h_num_flops(); if (KOKKOSKERNELS_VERBOSE){ @@ -708,7 +708,7 @@ void KokkosSPGEMM // ) , block_size); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << timer1.seconds() << " "; //std::cout << "\t\tAllocation WITH FIRST TOUCH TIME:" << timer1.seconds() << std::endl<< std::endl; @@ -746,7 +746,7 @@ void KokkosSPGEMM - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ outerproducttime += timer1.seconds(); //std::cout << "\t\tOuter Product TIME:" << timer1.seconds() << std::endl; @@ -777,7 +777,7 @@ void KokkosSPGEMM timer1.reset(); this->sort_triplets(fast_memory_triplets, num_block_flops); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ sorttime += timer1.seconds(); //std::cout << "\t\tTriplet Sort Time:" << timer1.seconds() << std::endl; @@ -790,7 +790,7 @@ void KokkosSPGEMM size_type outsize = this->collapse_triplets_omp( fast_memory_triplets, num_block_flops, collapsed_fast_memory_triplets); overall_size += outsize; - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ //std::cout << "\t\toutsize:" << outsize << std::endl; collapse_time += timer1.seconds(); @@ -807,7 +807,7 @@ void KokkosSPGEMM KokkosKernels::Impl::kk_copy_vector ( outsize,collapsed_fast_memory_triplets, host_triplet_arrays[bi]); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ copy_to_slow_mem_time += timer1.seconds(); //std::cout << "\t\tTriplet Copy To Slow Memory Time:" << timer1.seconds() << std::endl << std::endl; diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp index c0f0ac3c7d..276bd3de80 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_color.hpp @@ -429,7 +429,7 @@ void break; } } - MyExecSpace::fence(); + MyExecSpace().fence(); } if (KOKKOSKERNELS_VERBOSE){ @@ -493,7 +493,7 @@ void team_row_chunk_size, use_dynamic_schedule); - MyExecSpace::fence(); + MyExecSpace().fence(); } if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tTranspose Time:" << timer1.seconds() << std::endl; @@ -537,7 +537,7 @@ void KokkosKernels::Impl::kk_read_1Dview_from_file(vertex_color_view, this->handle->get_spgemm_handle()->coloring_input_file.c_str()); KokkosKernels::Impl::view_reduce_max (a_row_cnt, vertex_color_view, original_num_colors); - MyExecSpace::fence(); + MyExecSpace().fence(); //KokkosKernels::Impl::kk_print_1Dview(vertex_color_view); } @@ -551,7 +551,7 @@ void if (KOKKOSKERNELS_VERBOSE){ //create histogram and print it. nnz_lno_temp_work_view_t histogram ("histogram", original_num_colors + 1); - MyExecSpace::fence(); + MyExecSpace().fence(); timer1.reset(); KokkosKernels::Impl::kk_get_histogram (a_row_cnt, vertex_color_view, histogram); @@ -630,14 +630,14 @@ void (a_row_cnt, num_multi_color_steps, tmp_color_view, color_xadj, color_adj); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tReverse Map Create Time:" << timer1.seconds() << std::endl; } h_color_xadj = Kokkos::create_mirror_view (color_xadj); Kokkos::deep_copy (h_color_xadj, color_xadj); - MyExecSpace::fence(); + MyExecSpace().fence(); } this->handle->destroy_graph_coloring_handle(); } diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_compression.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_compression.hpp index 4fcfa0191e..62458f6e68 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_compression.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_compression.hpp @@ -800,7 +800,7 @@ bool KokkosSPGEMM set_begins_ = out_nnz_view_t (Kokkos::ViewAllocateWithoutInitializing("set_begins_"), nnz); Kokkos::deep_copy (set_begins_, -1); } - MyExecSpace::fence(); + MyExecSpace().fence(); #endif if (KOKKOSKERNELS_VERBOSE){ @@ -843,7 +843,7 @@ bool KokkosSPGEMM #ifndef KOKKOSKERNELSMOREMEM size_type max_row_nnz = 0; KokkosKernels::Impl::view_reduce_maxsizerow(n, in_row_map, max_row_nnz); - MyExecSpace::fence(); + MyExecSpace().fence(); KokkosKernels::Impl::PoolType my_pool_type = KokkosKernels::Impl::ManyThread2OneChunk; nnz_lno_t min_hash_size = 1; @@ -890,7 +890,7 @@ bool KokkosSPGEMM } nnz_lno_t pool_init_val = -1; pool_memory_space m_space(num_chunks, chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); sszm_compressMatrix.memory_space = m_space; #endif Kokkos::parallel_for("KokkosSparse::SingleStepZipMatrix::GPUEXEC", gpu_team_policy_t(n / suggested_team_size + 1 , suggested_team_size, suggested_vector_size), sszm_compressMatrix); @@ -903,7 +903,7 @@ bool KokkosSPGEMM { size_type max_row_nnz = 0; KokkosKernels::Impl::view_reduce_maxsizerow(n, in_row_map, max_row_nnz); - MyExecSpace::fence(); + MyExecSpace().fence(); KokkosKernels::Impl::PoolType my_pool_type = KokkosKernels::Impl::OneThread2OneChunk; nnz_lno_t min_hash_size = 1; @@ -929,7 +929,7 @@ bool KokkosSPGEMM } nnz_lno_t pool_init_val = -1; pool_memory_space m_space(num_chunks, chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); sszm_compressMatrix.memory_space = m_space; } @@ -939,7 +939,7 @@ bool KokkosSPGEMM else Kokkos::parallel_for( "KokkosSparse::TwoStepZipMatrix::use_ordered_compress", team_count_policy_t(n / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sszm_compressMatrix); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tCompression Count Kernel:" << timer_count.seconds() << std::endl; } @@ -999,7 +999,7 @@ bool KokkosSPGEMM } } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tCompression Kernel time:" << timer1.seconds() << std::endl; } diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_kkmem.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_kkmem.hpp index 9dc00a4910..28c12146a4 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_kkmem.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_kkmem.hpp @@ -1396,7 +1396,7 @@ void Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, chunksize, -1, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tPool Alloc Time:" << timer1.seconds() << std::endl; @@ -1442,7 +1442,7 @@ void if (lcl_my_exec_space == KokkosKernels::Impl::Exec_CUDA){ if (algorithm_to_run == SPGEMM_KK_MEMORY_SPREADTEAM){ Kokkos::parallel_for("KOKKOSPARSE::SPGEMM::SPGEMM_KK_MEMORY_SPREADTEAM", gpu_team_policy4_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); - MyExecSpace::fence(); + MyExecSpace().fence(); } else if (algorithm_to_run == SPGEMM_KK_MEMORY_BIGSPREADTEAM){ @@ -1452,7 +1452,7 @@ void Kokkos::parallel_for("KOKKOSPARSE::SPGEMM::SPGEMM_KK_MEMORY", gpu_team_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); } - MyExecSpace::fence(); + MyExecSpace().fence(); } else { if (algorithm_to_run == SPGEMM_KK_LP){ @@ -1474,7 +1474,7 @@ void Kokkos::parallel_for("KOKKOSPARSE::SPGEMM::KKMEM::STATIC", multicore_team_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); } } - MyExecSpace::fence(); + MyExecSpace().fence(); } if (KOKKOSKERNELS_VERBOSE){ @@ -1540,7 +1540,7 @@ void Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, chunksize, -1, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tPool Alloc Time:" << timer1.seconds() << std::endl; @@ -1586,7 +1586,7 @@ void if (my_exec_space_ == KokkosKernels::Impl::Exec_CUDA){ Kokkos::parallel_for("KOKKOSPARSE::SPGEMM::SPGEMM_KK_MEMORY2", gpu_team_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); - MyExecSpace::fence(); + MyExecSpace().fence(); } else { if (use_dynamic_schedule){ @@ -1597,7 +1597,7 @@ void Kokkos::parallel_for( "KOKKOSPARSE::SPGEMM::SPGEMM_KK_MEMORY_STATIC", multicore_team_policy2_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); } - MyExecSpace::fence(); + MyExecSpace().fence(); } if (KOKKOSKERNELS_VERBOSE){ diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_memaccess.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_memaccess.hpp index b3c88b62f7..3ceb74e2f3 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_memaccess.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_memaccess.hpp @@ -254,11 +254,11 @@ void KokkosSPGEMM //calculate how many flops per row is performed Kokkos::parallel_reduce( team_count_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), pcnnnz, overall_flops); - MyExecSpace::fence(); + MyExecSpace().fence(); //do a parallel prefix sum KokkosKernels::Impl::exclusive_parallel_prefix_sum(a_row_cnt+1, c_flop_rowmap); - MyExecSpace::fence(); + MyExecSpace().fence(); std::cout << "overall_flops:" << overall_flops << std::endl; @@ -277,7 +277,7 @@ void KokkosSPGEMM //fill the hypergraph values. //indices of nnzs for a and b nets, for c nets, the row and column index. Kokkos::parallel_for( team_fill_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), pcnnnz); - MyExecSpace::fence(); + MyExecSpace().fence(); } template b_col_cnt + (this->b_col_cnt) / sizeof(scalar_t) + 1, 0, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tPool Alloc Time:" << timer1.seconds() << std::endl; @@ -602,7 +602,7 @@ void my_exec_space_, team_row_chunk_size); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tCPU vector_size:" << suggested_vector_size << " team_size:" << suggested_team_size @@ -618,7 +618,7 @@ void Kokkos::parallel_for( "KokkosSparse::NumericCMEM_CPU::DENSE::STATIC", multicore_team_policy_t(a_row_cnt / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), sc); } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\t\tNumeric TIME:" << timer1.seconds() << std::endl; diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_symbolic.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_symbolic.hpp index cebc15b281..c3bdb136b0 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_symbolic.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_symbolic.hpp @@ -1689,7 +1689,7 @@ void KokkosSPGEMM } Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tPool Alloc Time:" << timer1.seconds() << std::endl; @@ -1758,7 +1758,7 @@ void KokkosSPGEMM } } } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tStructureC Kernel time:" << timer1.seconds() << std::endl<< std::endl; } @@ -1767,7 +1767,7 @@ void KokkosSPGEMM Kokkos::Impl::Timer timer1_; size_type c_max_nnz = 0; KokkosKernels::Impl::view_reduce_max(m, rowmapC, c_max_nnz); - MyExecSpace::fence(); + MyExecSpace().fence(); this->handle->get_spgemm_handle()->set_max_result_nnz(c_max_nnz); if (KOKKOSKERNELS_VERBOSE){ @@ -1776,7 +1776,7 @@ void KokkosSPGEMM } KokkosKernels::Impl::kk_exclusive_parallel_prefix_sum(m+1, rowmapC); - MyExecSpace::fence(); + MyExecSpace().fence(); auto d_c_nnz_size = Kokkos::subview(rowmapC, m); auto h_c_nnz_size = Kokkos::create_mirror_view (d_c_nnz_size); Kokkos::deep_copy (h_c_nnz_size, d_c_nnz_size); @@ -2017,7 +2017,7 @@ void KokkosSPGEMM } Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tPool Alloc Time:" << timer1.seconds() << std::endl; @@ -2085,7 +2085,7 @@ void KokkosSPGEMM } } } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tStructureC Kernel time:" << timer1.seconds() << std::endl<< std::endl; @@ -2123,7 +2123,7 @@ void KokkosSPGEMM typename c_row_view_t::HostMirror h_rowmapC = Kokkos::create_mirror_view (rowmapC); Kokkos::deep_copy(h_rowmapC, rowmapC); - MyExecSpace::fence(); + MyExecSpace().fence(); std::unordered_map flop_to_row_count; @@ -2270,7 +2270,7 @@ void KokkosSPGEMM Kokkos::Impl::Timer timer1_; size_type c_max_nnz = 0; KokkosKernels::Impl::view_reduce_max(m, rowmapC, c_max_nnz); - MyExecSpace::fence(); + MyExecSpace().fence(); this->handle->get_spgemm_handle()->set_max_result_nnz(c_max_nnz); if (KOKKOSKERNELS_VERBOSE){ @@ -2279,7 +2279,7 @@ void KokkosSPGEMM } KokkosKernels::Impl::kk_exclusive_parallel_prefix_sum(m+1, rowmapC); - MyExecSpace::fence(); + MyExecSpace().fence(); auto d_c_nnz_size = Kokkos::subview(rowmapC, m); auto h_c_nnz_size = Kokkos::create_mirror_view (d_c_nnz_size); Kokkos::deep_copy (h_c_nnz_size, d_c_nnz_size); @@ -2324,7 +2324,7 @@ size_t KokkosSPGEMM typename b_oldrow_view_t::non_const_value_type rough_size = 0; Kokkos::parallel_reduce( "KokkosSparse::PredicMaxRowNNZ::STATIC", team_policy_t(m / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), pcnnnz, rough_size); - MyExecSpace::fence(); + MyExecSpace().fence(); return rough_size; } @@ -2448,7 +2448,7 @@ size_t KokkosSPGEMM size_type rough_size = 0; Kokkos::parallel_reduce("KokkosSparse::PredicMaxRowNNZ_P::STATIC", team_policy_t(m / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), pcnnnz, rough_size); - MyExecSpace::fence(); + MyExecSpace().fence(); return rough_size; } @@ -2490,7 +2490,7 @@ size_t KokkosSPGEMM nnz_lno_t rough_size = 0; Kokkos::parallel_reduce( "KokkosSparse::PredicMaxRowNNZIntersection::STATIC", team_policy_t(m / team_row_chunk_size + 1 , suggested_team_size, suggested_vector_size), pcnnnz, rough_size); - MyExecSpace::fence(); + MyExecSpace().fence(); return rough_size; } diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_triangle.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_triangle.hpp index 019771316e..547cb97267 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_triangle.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_triangle.hpp @@ -1470,7 +1470,7 @@ void KokkosSPGEMM Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, accumulator_chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tPool Alloc Time:" << timer1.seconds() << std::endl; } @@ -1612,7 +1612,7 @@ void KokkosSPGEMM } } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tKernel time:" << timer1.seconds() << std::endl<< std::endl; @@ -1914,7 +1914,7 @@ void KokkosSPGEMM KokkosKernels::Impl::kk_exclusive_parallel_prefix_sum (this->a_row_cnt + 1, rowmapC_); - MyExecSpace::fence(); + MyExecSpace().fence(); auto d_c_nnz_size = Kokkos::subview(rowmapC_, this->a_row_cnt); auto h_c_nnz_size = Kokkos::create_mirror_view (d_c_nnz_size); diff --git a/src/sparse/impl/KokkosSparse_spgemm_impl_triangle_no_compression.hpp b/src/sparse/impl/KokkosSparse_spgemm_impl_triangle_no_compression.hpp index 5fdffc7d9e..21ba8b5c66 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_impl_triangle_no_compression.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_impl_triangle_no_compression.hpp @@ -1008,7 +1008,7 @@ void KokkosSPGEMM Kokkos::Impl::Timer timer1; pool_memory_space m_space(num_chunks, accumulator_chunksize, pool_init_val, my_pool_type); - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tPool Alloc Time:" << timer1.seconds() << std::endl; } @@ -1099,7 +1099,7 @@ void KokkosSPGEMM } } - MyExecSpace::fence(); + MyExecSpace().fence(); if (KOKKOSKERNELS_VERBOSE){ std::cout << "\tKernel time:" << timer1.seconds() << std::endl<< std::endl; diff --git a/src/sparse/impl/KokkosSparse_spgemm_viennaCL_impl.hpp b/src/sparse/impl/KokkosSparse_spgemm_viennaCL_impl.hpp index ec9cdb257a..da2b92d9a6 100644 --- a/src/sparse/impl/KokkosSparse_spgemm_viennaCL_impl.hpp +++ b/src/sparse/impl/KokkosSparse_spgemm_viennaCL_impl.hpp @@ -160,7 +160,7 @@ namespace Impl{ Kokkos::Impl::Timer timer1; viennacl::compressed_matrix C = viennacl::linalg::prod(A, B); - MyExecSpace::fence(); + MyExecSpace().fence(); if (verbose) std::cout << "Actual VIENNACL SPMM Time:" << timer1.seconds() << std::endl; @@ -187,11 +187,11 @@ namespace Impl{ //row_mapC = typename cin_row_index_view_type::non_const_type(Kokkos::ViewAllocateWithoutInitializing("rowmapC"), c_rows + 1); entriesC = typename cin_nonzero_index_view_type::non_const_type (Kokkos::ViewAllocateWithoutInitializing("EntriesC") , cnnz); valuesC = typename cin_nonzero_value_view_type::non_const_type (Kokkos::ViewAllocateWithoutInitializing("valuesC") , cnnz); - MyExecSpace::fence(); + MyExecSpace().fence(); KokkosKernels::Impl::copy_vector (m + 1, rows_start, row_mapC); KokkosKernels::Impl::copy_vector (cnnz, columns, entriesC); KokkosKernels::Impl::copy_vector (cnnz, values, valuesC); - MyExecSpace::fence(); + MyExecSpace().fence(); double copy_time_d = copy_time.seconds(); From 403ab1b8050431fe3ee4abcd6257c37caed1206c Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 15 May 2019 18:43:58 -0600 Subject: [PATCH 177/190] Update missed fence in agreement with Kokkos deprecations See kokkos/kokkos#2140 Update missed fence in .cpp file --- test_common/KokkosKernels_MatrixConverter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test_common/KokkosKernels_MatrixConverter.cpp b/test_common/KokkosKernels_MatrixConverter.cpp index 4a9f7e4134..8768b70c13 100644 --- a/test_common/KokkosKernels_MatrixConverter.cpp +++ b/test_common/KokkosKernels_MatrixConverter.cpp @@ -265,7 +265,7 @@ int main (int argc, char* argv[]){ new_entries = out_adj; new_values = out_vals; std::cout << 3 << std::endl; - MyExecSpace::fence(); + MyExecSpace().fence(); KokkosKernels::Impl::kk_print_1Dview(out_adj); KokkosKernels::Impl::kk_print_1Dview(out_vals); From 270df8db1cae3841a06188153c55e8813950e576 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 15 May 2019 18:48:36 -0600 Subject: [PATCH 178/190] Update rest of fences in .cpp files --- .../batched/KokkosBatched_Test_Gemm_Cuda.cpp | 26 +++++++++---------- .../batched/KokkosBatched_Test_LU_Cuda.cpp | 24 ++++++++--------- .../batched/KokkosBatched_Test_Trsm_Cuda.cpp | 22 ++++++++-------- perf_test/test_crsmatrix.cpp | 8 +++--- perf_test/test_mv.cpp | 12 ++++----- 5 files changed, 46 insertions(+), 46 deletions(-) diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp index bfb6d3d0f4..c18ac7d47c 100644 --- a/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp @@ -228,7 +228,7 @@ namespace KokkosBatched { Kokkos::deep_copy(amat_device, amat); Kokkos::deep_copy(bmat_device, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double one(1.0), zero(0.0); { @@ -243,7 +243,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat_device); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); stat = cublasDgemmStridedBatched(handle, @@ -257,7 +257,7 @@ namespace KokkosBatched { (value_type*)c.data(), BlkSize, BlkSize*BlkSize, N*VectorLength); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -306,12 +306,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::RangeTag", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -373,12 +373,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV1", policy,functor_type(a,b,c)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -446,12 +446,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV2", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -523,12 +523,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV3", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -595,12 +595,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyHandmade", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp index 4c2da01804..313b6517a2 100644 --- a/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp @@ -198,7 +198,7 @@ namespace KokkosBatched { auto amat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), amat); Kokkos::deep_copy(amat_device, amat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); { double tavg = 0, tmin = tmax; value_type *aa[N*VectorLength]; @@ -213,7 +213,7 @@ namespace KokkosBatched { if (cudaMemcpy(aa_device, aa, sizeof(value_type*)*N*VectorLength, cudaMemcpyHostToDevice) != cudaSuccess) { Kokkos::abort("CUDA memcpy failed\n"); } - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); for (int iter=iter_begin;iter= 0)*t; @@ -282,12 +282,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::RangeTag", policy, functor_type(a)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -341,12 +341,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV1", policy, functor_type(a)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -410,12 +410,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV2", policy, functor_type(a)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -482,13 +482,13 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV3", policy.set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)), functor_type(a)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp b/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp index d13bb215b5..2ebf666c1a 100644 --- a/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp +++ b/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp @@ -311,7 +311,7 @@ namespace KokkosBatched { Kokkos::deep_copy(amat_device, amat); Kokkos::deep_copy(bmat_device, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double one(1.0); //, zero(0.0); { @@ -334,7 +334,7 @@ namespace KokkosBatched { cudaMemcpy(bb_device, bb, sizeof(value_type*)*N*VectorLength, cudaMemcpyHostToDevice) != cudaSuccess) { Kokkos::abort("CUDA memcpy failed\n"); } - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); for (int iter=iter_begin;iter= 0)*t; @@ -473,12 +473,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::RangeTag", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -536,12 +536,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV1", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -608,12 +608,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV2", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -685,12 +685,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV3", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + DeviceSpaceType().fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/test_crsmatrix.cpp b/perf_test/test_crsmatrix.cpp index 38f605b66e..6c1ebe1fb0 100644 --- a/perf_test/test_crsmatrix.cpp +++ b/perf_test/test_crsmatrix.cpp @@ -317,7 +317,7 @@ int test_crs_matrix_test(LocalOrdinalType numRows, LocalOrdinalType numCols, Loc #else Kokkos::MV_Multiply(y,A,x); #endif - execution_space::fence(); + execution_space().fence(); Kokkos::deep_copy(h_y,y); Scalar error[numVecs]; Scalar sum[numVecs]; @@ -350,7 +350,7 @@ int test_crs_matrix_test(LocalOrdinalType numRows, LocalOrdinalType numCols, Loc #else Kokkos::MV_Multiply(y,A,x); #endif - execution_space::fence(); + execution_space().fence(); double time = timer.seconds(); double matrix_size = 1.0*((nnz*(sizeof(Scalar)+sizeof(LocalOrdinalType)) + numRows*sizeof(LocalOrdinalType)))/1024/1024; double vector_size = 2.0*numRows*numVecs*sizeof(Scalar)/1024/1024; @@ -434,7 +434,7 @@ int test_crs_matrix_test_singlevec(int numRows, int numCols, int nnz, int test, #else Kokkos::MV_Multiply(y,A,x); #endif - execution_space::fence(); + execution_space().fence(); Kokkos::deep_copy(h_y,y); Scalar error = 0; Scalar sum = 0; @@ -461,7 +461,7 @@ int test_crs_matrix_test_singlevec(int numRows, int numCols, int nnz, int test, #else Kokkos::MV_Multiply(y,A,x); #endif - execution_space::fence(); + execution_space().fence(); double time = timer.seconds(); double matrix_size = 1.0*((nnz*(sizeof(Scalar)+sizeof(int)) + numRows*sizeof(int)))/1024/1024; double vector_size = 2.0*numRows*sizeof(Scalar)/1024/1024; diff --git a/perf_test/test_mv.cpp b/perf_test/test_mv.cpp index c47953cee2..08bf65d8d8 100644 --- a/perf_test/test_mv.cpp +++ b/perf_test/test_mv.cpp @@ -101,7 +101,7 @@ void test_mv_dot(int size, int numVecs, int loop) h_vector_type h_b = h_a; MV_Dot(a,x,y); - execution_space::fence(); + execution_space().fence(); Kokkos::deep_copy(h_a,a); double errorsum=0; @@ -116,7 +116,7 @@ void test_mv_dot(int size, int numVecs, int loop) clock_gettime(CLOCK_REALTIME,&starttime); for(int i=0;i Date: Thu, 16 May 2019 10:53:01 -0600 Subject: [PATCH 179/190] KokkosBatched - add specialization for float2, float4 and double4. These are for testing two scalar type approach in ifpack2 --- .../KokkosBatched_Test_Gemm_Cuda.cpp | 0 .../KokkosBatched_Test_Gemm_Host.hpp | 0 .../KokkosBatched_Test_Gemm_Host_Complex.cpp | 0 .../KokkosBatched_Test_Gemm_Host_Real.cpp | 0 .../KokkosBatched_Test_Gemv_Host.hpp | 0 .../KokkosBatched_Test_Gemv_Host_Real.cpp | 0 .../KokkosBatched_Test_LU_Cuda.cpp | 0 .../KokkosBatched_Test_LU_Host.hpp | 0 .../KokkosBatched_Test_LU_Host_Real.cpp | 0 .../KokkosBatched_Test_Trsm_Cuda.cpp | 0 .../KokkosBatched_Test_Trsm_Host.hpp | 0 .../KokkosBatched_Test_Trsm_Host_Real.cpp | 0 src/batched/KokkosBatched_Vector_AVX256D.hpp | 677 ----------------- src/batched/KokkosBatched_Vector_AVX512D.hpp | 691 ------------------ src/batched/KokkosBatched_Vector_SIMD.hpp | 292 +++++++- .../KokkosBatched_Vector_SIMD_Arith.hpp | 165 ++++- 16 files changed, 426 insertions(+), 1399 deletions(-) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemm_Cuda.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemm_Host.hpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemm_Host_Complex.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemm_Host_Real.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemv_Host.hpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Gemv_Host_Real.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_LU_Cuda.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_LU_Host.hpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_LU_Host_Real.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Trsm_Cuda.cpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Trsm_Host.hpp (100%) rename perf_test/batched/{ => do-not-use}/KokkosBatched_Test_Trsm_Host_Real.cpp (100%) delete mode 100644 src/batched/KokkosBatched_Vector_AVX256D.hpp delete mode 100644 src/batched/KokkosBatched_Vector_AVX512D.hpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemm_Cuda.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host.hpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemm_Host.hpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host.hpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Host_Complex.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host_Complex.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemm_Host_Complex.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host_Complex.cpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host_Real.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemm_Host_Real.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Host_Real.cpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemv_Host.hpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemv_Host.hpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemv_Host.hpp diff --git a/perf_test/batched/KokkosBatched_Test_Gemv_Host_Real.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemv_Host_Real.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Gemv_Host_Real.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Gemv_Host_Real.cpp diff --git a/perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_LU_Cuda.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp diff --git a/perf_test/batched/KokkosBatched_Test_LU_Host.hpp b/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Host.hpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_LU_Host.hpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_LU_Host.hpp diff --git a/perf_test/batched/KokkosBatched_Test_LU_Host_Real.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Host_Real.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_LU_Host_Real.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_LU_Host_Real.cpp diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Trsm_Cuda.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Host.hpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Trsm_Host.hpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Host.hpp diff --git a/perf_test/batched/KokkosBatched_Test_Trsm_Host_Real.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Host_Real.cpp similarity index 100% rename from perf_test/batched/KokkosBatched_Test_Trsm_Host_Real.cpp rename to perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Host_Real.cpp diff --git a/src/batched/KokkosBatched_Vector_AVX256D.hpp b/src/batched/KokkosBatched_Vector_AVX256D.hpp deleted file mode 100644 index 0284537ffd..0000000000 --- a/src/batched/KokkosBatched_Vector_AVX256D.hpp +++ /dev/null @@ -1,677 +0,0 @@ -#ifndef __KOKKOSBATCHED_VECTOR_AVX256D_HPP__ -#define __KOKKOSBATCHED_VECTOR_AVX256D_HPP__ - -/// \author Kyungjoo Kim (kyukim@sandia.gov) - -#if defined(__AVX__) || defined(__AVX2__) - -#include - -namespace KokkosBatched { - { - - /// - /// AVX256D double - /// - - template<> - class Vector,4> { - public: - using type = Vector,4>; - using value_type = double; - using mag_type = double; - - static const int vector_length = 4; - - union data_type { - __m256d v; - double d[4]; - }; - - KOKKOS_INLINE_FUNCTION - static const char* label() { return "AVX256"; } - - private: - mutable data_type _data; - - public: - inline Vector() { _data.v = _mm256_setzero_pd(); } - inline Vector(const value_type val) { _data.v = _mm256_set1_pd(val); } - inline Vector(const type &b) { _data.v = b._data.v; } - inline Vector(__m256d const &val) { _data.v = val; } - - inline - type& operator=(__m256d const &val) { - _data.v = val; - return *this; - } - - inline - operator __m256d() const { - return _data.v; - } - - inline - type& loadAligned(value_type const *p) { - _data.v = _mm256_load_pd(p); - return *this; - } - - inline - type& loadUnaligned(value_type const *p) { - _data.v = _mm256_loadu_pd(p); - return *this; - } - - inline - void storeAligned(value_type *p) const { - _mm256_store_pd(p, _data.v); - } - - inline - void storeUnaligned(value_type *p) const { - _mm256_storeu_pd(p, _data.v); - } - - inline - value_type& operator[](int i) const { - return _data.d[i]; - } - }; - - - inline - static Vector,4> - operator + (Vector,4> const & a, Vector,4> const & b) { - return _mm256_add_pd(a, b); - } - - - inline - static Vector,4> - operator + (Vector,4> const & a, const double b) { - return a + Vector,4>(b); - } - - - inline - static Vector,4> - operator + (const double a, Vector,4> const & b) { - return Vector,4>(a) + b; - } - - - inline - static Vector,4> & - operator += (Vector,4> & a, Vector,4> const & b) { - a = a + b; - return a; - } - - - inline - static Vector,4> & - operator += (Vector,4> & a, const double b) { - a = a + b; - return a; - } - - - inline - static Vector,4> - operator ++ (Vector,4> & a, int) { - Vector,4> a0 = a; - a = a + 1.0; - return a0; - } - - - inline - static Vector,4> & - operator ++ (Vector,4> & a) { - a = a + 1.0; - return a; - } - - - inline - static Vector,4> - operator - (Vector,4> const & a, Vector,4> const & b) { - return _mm256_sub_pd(a, b); - } - - - inline - static Vector,4> - operator - (Vector,4> const & a, const double b) { - return a - Vector,4>(b); - } - - - inline - static Vector,4> - operator - (const double a, Vector,4> const & b) { - return Vector,4>(a) - b; - } - - - inline - static Vector,4> & - operator -= (Vector,4> & a, Vector,4> const & b) { - a = a - b; - return a; - } - - - inline - static Vector,4> & - operator -= (Vector,4> & a, const double b) { - a = a - b; - return a; - } - - - inline - static Vector,4> - operator -- (Vector,4> & a, int) { - Vector,4> a0 = a; - a = a - 1.0; - return a0; - } - - - inline - static Vector,4> & - operator -- (Vector,4> & a) { - a = a - 1.0; - return a; - } - - - inline - static Vector,4> - operator * (Vector,4> const & a, Vector,4> const & b) { - return _mm256_mul_pd(a, b); - } - - - inline - static Vector,4> - operator * (Vector,4> const & a, const double b) { - return a * Vector,4>(b); - } - - - inline - static Vector,4> operator * (const double a, Vector,4> const & b) { - return Vector,4>(a) * b; - } - - - inline - static Vector,4> & - operator *= (Vector,4> & a, Vector,4> const & b) { - a = a * b; - return a; - } - - - inline - static Vector,4> & - operator *= (Vector,4> & a, const double b) { - a = a * b; - return a; - } - - - inline - static Vector,4> - operator / (Vector,4> const & a, Vector,4> const & b) { - return _mm256_div_pd(a, b); - } - - - inline - static Vector,4> - operator / (Vector,4> const & a, const double b) { - return a / Vector,4>(b); - } - - - inline - static Vector,4> - operator / (const double a, Vector,4> const & b) { - return Vector,4>(a) / b; - } - - - inline - static Vector,4> & - operator /= (Vector,4> & a, Vector,4> const & b) { - a = a / b; - return a; - } - - - inline - static Vector,4> & - operator /= (Vector,4> & a, const double b) { - a = a / b; - return a; - } - - - inline - static Vector,4> - operator - (Vector,4> const & a) { - return -1.0*a; - } - - /// - /// AVX256D Kokkos::complex - // - - template<> - class Vector >,2> { - public: - using type = Vector >,2>; - using value_type = Kokkos::complex; - using mag_type = double; - - static const int vector_length = 2; - - union data_type { - __m256d v; - Kokkos::complex d[2]; - - data_type() { v = _mm256_setzero_pd(); } - data_type(const data_type &b) { v = b.v; } - }; - - KOKKOS_INLINE_FUNCTION - static const char* label() { return "AVX256"; } - - private: - mutable data_type _data; - - public: - inline Vector() { _data.v = _mm256_setzero_pd(); } - inline Vector(const value_type val) { _data.v = _mm256_broadcast_pd((__m128d const *)&val);} - inline Vector(const mag_type val) { const value_type a(val); _data.v = _mm256_broadcast_pd((__m128d const *)&a); } - inline Vector(const type &b) { _data.v = b._data.v; } - inline Vector(__m256d const &val) { _data.v = val; } - - inline - type& operator=(__m256d const &val) { - _data.v = val; - return *this; - } - - inline - operator __m256d() const { - return _data.v; - } - - inline - type& loadAligned(value_type const *p) { - _data.v = _mm256_load_pd((mag_type*)p); - return *this; - } - - inline - type& loadUnaligned(value_type const *p) { - _data.v = _mm256_loadu_pd((mag_type*)p); - return *this; - } - - inline - void storeAligned(value_type *p) const { - _mm256_store_pd((mag_type*)p, _data.v); - } - - inline - void storeUnaligned(value_type *p) const { - _mm256_storeu_pd((mag_type*)p, _data.v); - } - - inline - value_type& operator[](int i) const { - return _data.d[i]; - } - }; - - /// complex vector , complex vector - - - inline - static Vector >,2> - operator + (Vector >,2> const & a, Vector >,2> const & b) { - return _mm256_add_pd(a, b); - } - - - inline - static Vector >,2> & - operator += (Vector >,2> & a, Vector >,2> const & b) { - a = a + b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,2> - operator + (Vector >,2> const & a, const Kokkos::complex b) { - return a + Vector >,2>(b); - } - - - inline - static Vector >,2> - operator + (const Kokkos::complex a, Vector >,2> const & b) { - return Vector >,2>(a) + b; - } - - - inline - static Vector >,2> & - operator += (Vector >,2> & a, const Kokkos::complex b) { - a = a + b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,2> - operator + (Vector >,2> const & a, const double b) { - return a + Vector >,2>(b); - } - - - inline - static Vector >,2> - operator + (const double a, Vector >,2> const & b) { - return Vector >,2>(a) + b; - } - - - inline - static Vector >,2> & - operator += (Vector >,2> & a, const double b) { - a = a + b; - return a; - } - - /// unitary operator - - - inline - static Vector >,2> - operator ++ (Vector >,2> & a, int) { - Vector >,2> a0 = a; - a = a + 1.0; - return a0; - } - - - inline - static Vector >,2> & - operator ++ (Vector >,2> & a) { - a = a + 1.0; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,2> - operator - (Vector >,2> const & a, Vector >,2> const & b) { - return _mm256_sub_pd(a, b); - } - - - inline - static Vector >,2> & - operator -= (Vector >,2> & a, Vector >,2> const & b) { - a = a - b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,2> - operator - (Vector >,2> const & a, const Kokkos::complex b) { - return a - Vector >,2>(b); - } - - - inline - static Vector >,2> - operator - (const Kokkos::complex a, Vector >,2> const & b) { - return Vector >,2>(a) - b; - } - - - inline - static Vector >,2> & - operator -= (Vector >,2> & a, const Kokkos::complex b) { - a = a - b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,2> - operator - (Vector >,2> const & a, const double b) { - return a - Vector >,2>(b); - } - - - inline - static Vector >,2> - operator - (const double a, Vector >,2> const & b) { - return Vector >,2>(a) - b; - } - - - inline - static Vector >,2> & - operator -= (Vector >,2> & a, const double b) { - a = a - b; - return a; - } - - /// unitary operator - - - inline - static Vector >,2> - operator -- (Vector >,2> & a, int) { - Vector >,2> a0 = a; - a = a - 1.0; - return a0; - } - - - inline - static Vector >,2> & - operator -- (Vector >,2> & a) { - a = a - 1.0; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,2> - operator * (Vector >,2> const & a, Vector >,2> const & b) { - const __m256d - as = _mm256_permute_pd(a, 0x5), - br = _mm256_permute_pd(b, 0x0), - bi = _mm256_permute_pd(b, 0xf); - -#if defined(__FMA__) - return _mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)); -#else - return _mm256_add_pd(_mm256_mul_pd(a, br), - _mm256_xor_pd(_mm256_mul_pd(as, bi), - _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))); -#endif - } - - - inline - static Vector >,2> & - operator *= (Vector >,2> & a, Vector >,2> const & b) { - a = a * b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,2> - operator * (Vector >,2> const & a, const Kokkos::complex b) { - return a * Vector >,2>(b); - } - - - inline - static Vector >,2> - operator * (const Kokkos::complex a, Vector >,2> const & b) { - return Vector >,2>(a) * b; - } - - - inline - static Vector >,2> & - operator *= (Vector >,2> & a, const Kokkos::complex b) { - a = a * b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,2> - operator * (Vector >,2> const & a, const double b) { - return _mm256_mul_pd(a, _mm256_set1_pd(b)); - } - - - inline - static Vector >,2> - operator * (const double a, Vector >,2> const & b) { - return _mm256_mul_pd(_mm256_set1_pd(a), b); - } - - - inline - static Vector >,2> & - operator *= (Vector >,2> & a, const double b) { - a = a * b; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,2> - operator / (Vector >,2> const & a, Vector >,2> const & b) { - const __m256d - as = _mm256_permute_pd(a, 0x5), - cb = _mm256_xor_pd(b, _mm256_set_pd(-0.0, 0.0, -0.0, 0.0)), - br = _mm256_permute_pd(cb, 0x0), - bi = _mm256_permute_pd(cb, 0xf); - -#if defined(__FMA__) - return _mm256_div_pd(_mm256_fmaddsub_pd(a, br, _mm256_mul_pd(as, bi)), - _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); -#else - return _mm256_div_pd(_mm256_add_pd(_mm256_mul_pd(a, br), - _mm256_xor_pd(_mm256_mul_pd(as, bi), - _mm256_set_pd( 0.0, -0.0, 0.0, -0.0))), - _mm256_add_pd(_mm256_mul_pd(br, br), _mm256_mul_pd(bi, bi))); -#endif - } - - - inline - static Vector >,2> & - operator /= (Vector >,2> & a, Vector >,2> const & b) { - a = a / b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,2> - operator / (Vector >,2> const & a, const Kokkos::complex b) { - return a / Vector >,2>(b); - } - - - inline - static Vector >,2> - operator / (const Kokkos::complex a, Vector >,2> const & b) { - return Vector >,2>(a) / b; - } - - - inline - static Vector >,2> & - operator /= (Vector >,2> & a, const Kokkos::complex b) { - a = a / b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,2> - operator / (Vector >,2> const & a, const double b) { - return _mm256_div_pd(a, _mm256_set1_pd(b)); - } - - - inline - static Vector >,2> - operator / (const double a, Vector >,2> const & b) { - return Vector >,2>(a) / b; - } - - - inline - static Vector >,2> & - operator /= (Vector >,2> & a, const double b) { - a = a / b; - return a; - } - - - inline - static Vector >,2> - operator - (Vector >,2> const & a) { - return -1.0*a; - } - - } -} - -#endif -#endif diff --git a/src/batched/KokkosBatched_Vector_AVX512D.hpp b/src/batched/KokkosBatched_Vector_AVX512D.hpp deleted file mode 100644 index 591ba09f01..0000000000 --- a/src/batched/KokkosBatched_Vector_AVX512D.hpp +++ /dev/null @@ -1,691 +0,0 @@ -#ifndef __KOKKOSBATCHED_VECTOR_AVX512D_HPP__ -#define __KOKKOSBATCHED_VECTOR_AVX512D_HPP__ - -/// \author Kyungjoo Kim (kyukim@sandia.gov) -#if defined(__AVX512F__) - -#include - -namespace KokkosBatched { - { - /// - /// AVX512D double - /// - template<> - class Vector,8> { - public: - using type = Vector,8>; - using value_type = double; - using mag_type = double; - - static const int vector_length = 8; - - union data_type { - __m512d v; - double d[8]; - }; - - KOKKOS_INLINE_FUNCTION - static const char* label() { return "AVX512"; } - - private: - mutable data_type _data; - - public: - inline Vector() { _data.v = _mm512_setzero_pd(); } - inline Vector(const value_type val) { _data.v = _mm512_set1_pd(val); } - inline Vector(const type &b) { _data.v = b._data.v; } - inline Vector(__m512d const &val) { _data.v = val; } - - inline - type& operator=(__m512d const &val) { - _data.v = val; - return *this; - } - - inline - operator __m512d() const { - return _data.v; - } - - inline - type& loadAligned(value_type const *p) { - _data.v = _mm512_load_pd(p); - return *this; - } - - inline - type& loadUnaligned(value_type const *p) { - _data.v = _mm512_loadu_pd(p); - return *this; - } - - inline - void storeAligned(value_type *p) const { - _mm512_store_pd(p, _data.v); - } - - inline - void storeUnaligned(value_type *p) const { - _mm512_storeu_pd(p, _data.v); - } - - inline - value_type& operator[](int i) const { - return _data.d[i]; - } - }; - - - inline - static Vector,8> - operator + (const Vector,8> &a, const Vector,8> &b) { - return _mm512_add_pd(a, b); - } - - - inline - static Vector,8> - operator + (const Vector,8> &a, const double b) { - return a + Vector,8>(b); - } - - - inline - static Vector,8> - operator + (const double a, const Vector,8> &b) { - return Vector,8>(a) + b; - } - - - inline - static Vector,8> & - operator += (Vector,8> &a, const Vector,8> &b) { - a = a + b; - return a; - } - - - inline - static Vector,8> & - operator += (Vector,8> &a, const double b) { - a = a + b; - return a; - } - - - inline - static Vector,8> - operator ++ (Vector,8> &a, int) { - Vector,8> a0 = a; - a = a + 1.0; - return a0; - } - - - inline - static Vector,8> & - operator ++ (Vector,8> &a) { - a = a + 1.0; - return a; - } - - - inline - static Vector,8> - operator - (const Vector,8> &a, const Vector,8> &b) { - return _mm512_sub_pd(a, b); - } - - - inline - static Vector,8> - operator - (const Vector,8> &a, const double b) { - return a - Vector,8>(b); - } - - - inline - static Vector,8> - operator - (const double a, const Vector,8> &b) { - return Vector,8>(a) - b; - } - - - inline - static Vector,8> & - operator -= (Vector,8> &a, const Vector,8> &b) { - a = a - b; - return a; - } - - - inline - static Vector,8> & - operator -= (Vector,8> &a, const double b) { - a = a - b; - return a; - } - - - inline - static Vector,8> - operator -- (Vector,8> &a, int) { - Vector,8> a0 = a; - a = a - 1.0; - return a0; - } - - - inline - static Vector,8> & - operator -- (Vector,8> &a) { - a = a - 1.0; - return a; - } - - - inline - static Vector,8> - operator * (const Vector,8> &a, const Vector,8> &b) { - return _mm512_mul_pd(a, b); - } - - - inline - static Vector,8> - operator * (const Vector,8> &a, const double b) { - return a * Vector,8>(b); - } - - - inline - static Vector,8> - operator * (const double a, const Vector,8> &b) { - return Vector,8>(a) * b; - } - - - inline - static Vector,8> & - operator *= (Vector,8> &a, const Vector,8> &b) { - a = a * b; - return a; - } - - - inline - static Vector,8> & - operator *= (Vector,8> &a, const double b) { - a = a * b; - return a; - } - - - inline - static Vector,8> - operator / (const Vector,8> &a, const Vector,8> &b) { - return _mm512_div_pd(a, b); - } - - - inline - static Vector,8> - operator / (const Vector,8> &a, const double b) { - return a / Vector,8>(b); - } - - - inline - static Vector,8> - operator / (const double a, const Vector,8> &b) { - return Vector,8>(a) / b; - } - - - inline - static Vector,8> & - operator /= (Vector,8> &a, const Vector,8> &b) { - a = a / b; - return a; - } - - - inline - static Vector,8> & - operator /= (Vector,8> &a, const double b) { - a = a / b; - return a; - } - - - inline - static Vector,8> - operator - (const Vector,8> &a) { - return -1*a; - } - - /// - /// AVX512D Kokkos::complex - /// - - - template<> - class Vector >,4> { - public: - using type = Vector,4> >; - using value_type = Kokkos::complex; - using mag_type = double; - - static const int vector_length = 4; - - union data_type { - __m512d v; - Kokkos::complex d[4]; - - data_type() { v = _mm512_setzero_pd(); } - data_type(const data_type &b) { v = b.v; } - }; - - KOKKOS_INLINE_FUNCTION - static const char* label() { return "AVX512"; } - - private: - mutable data_type _data; - - public: - inline Vector() { _data.v = _mm512_setzero_pd(); } - inline Vector(const value_type val) { - _data.v = _mm512_mask_broadcast_f64x4(_mm512_set1_pd(val.imag()), 0x55, _mm256_set1_pd(val.real())); - } - inline Vector(const mag_type val) { - _data.v = _mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, _mm256_set1_pd(val)); - } - inline Vector(const type &b) { _data.v = b._data.v; } - inline Vector(__m512d const &val) { _data.v = val; } - - inline - type& operator=(__m512d const &val) { - _data.v = val; - return *this; - } - - inline - operator __m512d() const { - return _data.v; - } - - inline - type& loadAligned(value_type const *p) { - _data.v = _mm512_load_pd((mag_type*)p); - return *this; - } - - inline - type& loadUnaligned(value_type const *p) { - _data.v = _mm512_loadu_pd((mag_type*)p); - return *this; - } - - inline - void storeAligned(value_type *p) const { - _mm512_store_pd((mag_type*)p, _data.v); - } - - inline - void storeUnaligned(value_type *p) const { - _mm512_storeu_pd((mag_type*)p, _data.v); - } - - inline - value_type& operator[](int i) const { - return _data.d[i]; - } - - }; - - /// complex vector , complex vector - - - inline - static Vector >,4> - operator + (const Vector >,4> &a, const Vector >,4> &b) { - return _mm512_add_pd(a, b); - } - - - inline - static Vector >,4> & - operator += (Vector >,4> &a, const Vector >,4> &b) { - a = a + b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,4> - operator + (const Vector >,4> &a, const Kokkos::complex b) { - return a + Vector >,4>(b); - } - - - inline - static Vector >,4> - operator + (const Kokkos::complex a, const Vector >,4> &b) { - return Vector >,4>(a) + b; - } - - - inline - static Vector >,4> & - operator += (Vector >,4> &a, const Kokkos::complex b) { - a = a + b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,4> - operator + (const Vector >,4> &a, const double b) { - return a + Vector >,4>(b); - } - - - inline - static Vector >,4> - operator + (const double a, const Vector >,4> &b) { - return Vector >,4>(a) + b; - } - - - inline - static Vector >,4> & - operator += (Vector >,4> &a, const double b) { - a = a + b; - return a; - } - - /// unitary operator - - - inline - static Vector >,4> - operator ++ (Vector >,4> &a, int) { - Vector >,4> a0 = a; - a = a + 1.0; - return a0; - } - - - inline - static Vector >,4> & - operator ++ (Vector >,4> &a) { - a = a + 1.0; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,4> - operator - (const Vector >,4> &a, const Vector >,4> &b) { - return _mm512_sub_pd(a, b); - } - - - inline - static Vector >,4> & - operator -= (Vector >,4> &a, const Vector >,4> &b) { - a = a - b; - return a; - } - - /// unitary operator - - - inline - static Vector >,4> - operator -- (Vector >,4> &a, int) { - Vector >,4> a0 = a; - a = a - 1.0; - return a0; - } - - - inline - static Vector >,4> & - operator -- (Vector >,4> &a) { - a = a - 1.0; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,4> - operator - (const Vector >,4> &a, const Kokkos::complex b) { - return a - Vector >,4>(b); - } - - - inline - static Vector >,4> - operator - (const Kokkos::complex a, const Vector >,4> &b) { - return Vector >,4>(a) - b; - } - - - inline - static Vector >,4> & - operator -= (Vector >,4> &a, const Kokkos::complex b) { - a = a - b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,4> - operator - (const Vector >,4> &a, const double b) { - return a - Vector >,4>(b); - } - - - inline - static Vector >,4> - operator - (const double a, const Vector >,4> &b) { - return Vector >,4>(a) - b; - } - - - inline - static Vector >,4> & - operator -= (Vector >,4> &a, const double b) { - a = a - b; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,4> - operator * (const Vector >,4> &a, const Vector >,4> &b) { - const __m512d - as = _mm512_permute_pd(a, 0x55), - br = _mm512_permute_pd(b, 0x00), - bi = _mm512_permute_pd(b, 0xff); - -#if defined(__FMA__) - // latency 7, throughput 0.5 - return _mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)); -#else - return _mm512_add_pd(_mm512_mul_pd(a, br), - _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0x55, - _mm256_set1_pd(-0.0)))))); - // const __mm512d cc = _mm512_mul_pd(as, bi); - // return _mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc); -#endif - } - - - inline - static Vector >,4> & - operator *= (Vector >,4> &a, const Vector >,4> &b) { - a = a * b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,4> - operator * (const Vector >,4> &a, const Kokkos::complex b) { - return a * Vector >,4>(b); - } - - - inline - static Vector >,4> - operator * (const Kokkos::complex a, const Vector >,4> &b) { - return Vector >,4>(a) * b; - } - - - inline - static Vector >,4> & - operator *= (Vector >,4> &a, const Kokkos::complex b) { - a = a * b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,4> - operator * (const Vector >,4> &a, const double b) { - return _mm512_mul_pd(a, _mm512_set1_pd(b)); - } - - - inline - static Vector >,4> - operator * (const double a, const Vector >,4> &b) { - return _mm512_mul_pd(_mm512_set1_pd(a), b); - } - - - inline - static Vector >,4> & - operator *= (Vector >,4> &a, const double b) { - a = a * b; - return a; - } - - /// complex vector , complex vector - - - inline - static Vector >,4> - operator / (const Vector >,4> &a, const Vector >,4> &b) { - const __m512d - as = _mm512_permute_pd(a, 0x55), - cb = _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(b), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, - _mm256_set1_pd(-0.0))))), - br = _mm512_permute_pd(cb, 0x00), - bi = _mm512_permute_pd(cb, 0xff); - -#if defined(__FMA__) - return _mm512_div_pd(_mm512_fmaddsub_pd(a, br, _mm512_mul_pd(as, bi)), - _mm512_fmadd_pd (br, br, _mm512_mul_pd(bi, bi))); -#else - return _mm512_div_pd(_mm512_add_pd(_mm512_mul_pd(a, br), - _mm512_castsi512_pd(_mm512_xor_si512(_mm512_castpd_si512(_mm512_mul_pd(as, bi)), - _mm512_castpd_si512(_mm512_mask_broadcast_f64x4(_mm512_setzero_pd(), 0xAA, - _mm256_set1_pd(-0.0)))))), - _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); - // const __mm512d cc = _mm512_mul_pd(as, bi); - // return _mm512_div_pd(_mm512_mask_sub_pd(_mm512_mask_add_pd(_mm512_mul_pd(a, br), 0x55, cc), 0xaa, cc), - // _mm512_add_pd(_mm512_mul_pd(br, br), _mm512_mul_pd(bi, bi))); -#endif - } - - - inline - static Vector >,4> & - operator /= (Vector >,4> &a, const Vector >,4> &b) { - a = a / b; - return a; - } - - /// complex vector , complex - - - inline - static Vector >,4> - operator / (const Vector >,4> &a, const Kokkos::complex b) { - return a / Vector >,4>(b); - } - - - inline - static Vector >,4> - operator / (const Kokkos::complex a, const Vector >,4> &b) { - return Vector >,4>(a) / b; - } - - - - inline - static Vector >,4> & - operator /= (Vector >,4> &a, const Kokkos::complex b) { - a = a / b; - return a; - } - - /// complex vector , real - - - inline - static Vector >,4> - operator / (const Vector >,4> &a, const double b) { - return _mm512_div_pd(a, _mm512_set1_pd(b)); - } - - - inline - static Vector >,4> - operator / (const double a, const Vector >,4> &b) { - return Vector >,4>(a) / b; - } - - - inline - static Vector >,4> & - operator /= (Vector >,4> &a, const double b) { - a = a / b; - return a; - } - - - inline - static Vector >,4> - operator - (const Vector >,4> &a) { - return -1.0*a; - } - - } -} -#endif -#endif diff --git a/src/batched/KokkosBatched_Vector_SIMD.hpp b/src/batched/KokkosBatched_Vector_SIMD.hpp index 388519c772..204d614d14 100644 --- a/src/batched/KokkosBatched_Vector_SIMD.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD.hpp @@ -15,20 +15,6 @@ namespace KokkosBatched { - template - struct TypeTraits { - typedef T thread_private_type; - typedef T team_private_type; - }; - - template - struct TypeTraits,l>, v> { - typedef typename std::conditional::value, - Vector,l>, T>::type thread_private_type; - typedef typename std::conditional::value, - Vector,l>, Vector,(l/v)+(l%v>0)> > team_private_type; - }; - template class Vector,l> { public: @@ -38,11 +24,7 @@ namespace KokkosBatched { enum : int { vector_length = l }; -#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) - typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; -#else typedef value_type data_type[vector_length]; -#endif KOKKOS_INLINE_FUNCTION static const char* label() { return "SIMD"; } @@ -135,6 +117,87 @@ namespace KokkosBatched { #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) namespace KokkosBatched { + template<> + class Vector,2> { + public: + using type = Vector,2>; + using value_type = float; + using mag_type = float; + + enum : int { vector_length = 2 }; + typedef float2 data_type; + + KOKKOS_INLINE_FUNCTION + static const char* label() { return "CudaFloat2"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; } + KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; } + KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; } + KOKKOS_INLINE_FUNCTION Vector(const float2 &val) { _data.x = val.x; _data.y = val.y; } + + template + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + _data.x = val; + _data.y = val; + } + + template + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + _data.x = b[0]; + _data.y = b[1]; + } + + KOKKOS_INLINE_FUNCTION + type& operator=(const float2 &val) { + _data.x = val.x; + _data.y = val.y; + return *this; + } + + KOKKOS_INLINE_FUNCTION + float2 float2() const { + return _data; + } + + KOKKOS_INLINE_FUNCTION + type& loadAligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + type& loadUnaligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + return *this; + } + + KOKKOS_INLINE_FUNCTION + void storeAligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + void storeUnaligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + } + + KOKKOS_INLINE_FUNCTION + value_type& operator[](const int &i) const { + return reinterpret_cast(&_data)[i]; + } + }; + template<> class Vector,2> { public: @@ -143,7 +206,6 @@ namespace KokkosBatched { using mag_type = double; enum : int { vector_length = 2 }; - //typedef __device_builtin__ __builtin_align__(16) value_type data_type[vector_length]; typedef double2 data_type; KOKKOS_INLINE_FUNCTION @@ -216,6 +278,198 @@ namespace KokkosBatched { return reinterpret_cast(&_data)[i]; } }; + + template<> + class Vector,4> { + public: + using type = Vector,4>; + using value_type = float; + using mag_type = float; + + enum : int { vector_length = 4 }; + typedef float4 data_type; + + KOKKOS_INLINE_FUNCTION + static const char* label() { return "CudaFloat4"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; _data.z = 0; _data.w = 0; } + KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; _data.z = val; _data.w = val; } + KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; _data.z = b._data.z; _data.w = b._data.w; } + KOKKOS_INLINE_FUNCTION Vector(const float4 &val) { _data.x = val.x; _data.y = val.y; _data.z = val.z; _data.w = val.w; } + + template + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + _data.x = val; + _data.y = val; + _data.z = val; + _data.w = val; + } + + template + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + _data.x = b[0]; + _data.y = b[1]; + _data.z = b[2]; + _data.w = b[3]; + } + + KOKKOS_INLINE_FUNCTION + type& operator=(const float4 &val) { + _data.x = val.x; + _data.y = val.y; + _data.z = val.z; + _data.w = val.w; + return *this; + } + + KOKKOS_INLINE_FUNCTION + float4 float4() const { + return _data; + } + + KOKKOS_INLINE_FUNCTION + type& loadAligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + _data.z = *(p+2); + _data.w = *(p+3); + return *this; + } + + KOKKOS_INLINE_FUNCTION + type& loadUnaligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + _data.z = *(p+2); + _data.w = *(p+3); + return *this; + } + + KOKKOS_INLINE_FUNCTION + void storeAligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + *(p+2) = _data.z; + *(p+3) = _data.w; + } + + KOKKOS_INLINE_FUNCTION + void storeUnaligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + *(p+2) = _data.z; + *(p+3) = _data.w; + } + + KOKKOS_INLINE_FUNCTION + value_type& operator[](const int &i) const { + return reinterpret_cast(&_data)[i]; + } + }; + + template<> + class Vector,4> { + public: + using type = Vector,4>; + using value_type = double; + using mag_type = double; + + enum : int { vector_length = 4 }; + typedef double4 data_type; + + KOKKOS_INLINE_FUNCTION + static const char* label() { return "CudaDouble4"; } + + template + friend class Vector; + + private: + mutable data_type _data; + + public: + KOKKOS_INLINE_FUNCTION Vector() { _data.x = 0; _data.y = 0; _data.z = 0; _data.w = 0; } + KOKKOS_INLINE_FUNCTION Vector(const value_type &val) { _data.x = val; _data.y = val; _data.z = val; _data.w = val; } + KOKKOS_INLINE_FUNCTION Vector(const type &b) { _data.x = b._data.x; _data.y = b._data.y; _data.z = b._data.z; _data.w = b._data.w; } + KOKKOS_INLINE_FUNCTION Vector(const double4 &val) { _data.x = val.x; _data.y = val.y; _data.z = val.z; _data.w = val.w; } + + template + KOKKOS_INLINE_FUNCTION Vector(const ArgValueType &val) { + _data.x = val; + _data.y = val; + _data.z = val; + _data.w = val; + } + + template + KOKKOS_INLINE_FUNCTION Vector(const Vector,vector_length> &b) { + _data.x = b[0]; + _data.y = b[1]; + _data.z = b[2]; + _data.w = b[3]; + } + + KOKKOS_INLINE_FUNCTION + type& operator=(const double4 &val) { + _data.x = val.x; + _data.y = val.y; + _data.z = val.z; + _data.w = val.w; + return *this; + } + + KOKKOS_INLINE_FUNCTION + double4 double4() const { + return _data; + } + + KOKKOS_INLINE_FUNCTION + type& loadAligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + _data.z = *(p+2); + _data.w = *(p+3); + return *this; + } + + KOKKOS_INLINE_FUNCTION + type& loadUnaligned(const value_type *p) { + _data.x = *(p ); + _data.y = *(p+1); + _data.z = *(p+2); + _data.w = *(p+3); + return *this; + } + + KOKKOS_INLINE_FUNCTION + void storeAligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + *(p+2) = _data.z; + *(p+3) = _data.w; + } + + KOKKOS_INLINE_FUNCTION + void storeUnaligned(value_type *p) const { + *(p ) = _data.x; + *(p+1) = _data.y; + *(p+2) = _data.z; + *(p+3) = _data.w; + } + + KOKKOS_INLINE_FUNCTION + value_type& operator[](const int &i) const { + return reinterpret_cast(&_data)[i]; + } + }; + + } #endif diff --git a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp index 28826abf66..efc6d4dacc 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp @@ -69,15 +69,51 @@ namespace KokkosBatched { } #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) + operator + (const Vector,2> &a, const Vector,2> &b) { + const float2 aa(a), bb(b); + /* */ float2 r_val; + r_val.x = aa.x + bb.x; + r_val.y = aa.y + bb.y; + return r_val; + } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator + (const Vector,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x + b.double2().x; - r_val.y = a.double2().y + b.double2().y; + const double2 aa(a), bb(b); + /* */ double2 r_val; + r_val.x = aa.x + bb.x; + r_val.y = aa.y + bb.y; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) + operator + (const Vector,4> &a, const Vector,4> &b) { + const float4 aa(a), bb(b); + /* */ float4 r_val; + r_val.x = aa.x + bb.x; + r_val.y = aa.y + bb.y; + r_val.z = aa.z + bb.z; + r_val.w = aa.w + bb.w; return r_val; } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + operator + (const Vector,4> &a, const Vector,4> &b) { + const double4 aa(a), bb(b); + /* */ double4 r_val; + r_val.x = aa.x + bb.x; + r_val.y = aa.y + bb.y; + r_val.z = aa.z + bb.z; + r_val.w = aa.w + bb.w; + return r_val; + } + #endif template @@ -250,13 +286,48 @@ namespace KokkosBatched { } #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) + operator - (const Vector,2> &a, const Vector,2> &b) { + const float2 aa(a), bb(b); + /* */ float2 r_val; + r_val.x = aa.x - bb.x; + r_val.y = aa.y - bb.y; + return r_val; + } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator - (const Vector,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x - b.double2().x; - r_val.y = a.double2().y - b.double2().y; + const double2 aa(a), bb(b); + /* */ double2 r_val; + r_val.x = aa.x - bb.x; + r_val.y = aa.y - bb.y; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) + operator - (const Vector,4> &a, const Vector,4> &b) { + const float4 aa(a), bb(b); + /* */ float4 r_val; + r_val.x = aa.x - bb.x; + r_val.y = aa.y - bb.y; + r_val.z = aa.z - bb.z; + r_val.w = aa.w - bb.w; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + operator - (const Vector,4> &a, const Vector,4> &b) { + const double4 aa(a), bb(b); + /* */ double4 r_val; + r_val.x = aa.x - bb.x; + r_val.y = aa.y - bb.y; + r_val.z = aa.z - bb.z; + r_val.w = aa.w - bb.w; return r_val; } #endif @@ -473,13 +544,48 @@ namespace KokkosBatched { } #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) + operator * (const Vector,2> &a, const Vector,2> &b) { + const float2 aa(a), bb(b); + /* */ float2 r_val; + r_val.x = aa.x * bb.x; + r_val.y = aa.y * bb.y; + return r_val; + } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator * (const Vector,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x * b.double2().x; - r_val.y = a.double2().y * b.double2().y; + const double2 aa(a), bb(b); + /* */ double2 r_val; + r_val.x = aa.x * bb.x; + r_val.y = aa.y * bb.y; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) + operator * (const Vector,4> &a, const Vector,4> &b) { + const float4 aa(a), bb(b); + /* */ float4 r_val; + r_val.x = aa.x * bb.x; + r_val.y = aa.y * bb.y; + r_val.z = aa.z * bb.z; + r_val.w = aa.w * bb.w; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + operator * (const Vector,4> &a, const Vector,4> &b) { + const double4 aa(a), bb(b); + /* */ double4 r_val; + r_val.x = aa.x * bb.x; + r_val.y = aa.y * bb.y; + r_val.z = aa.z * bb.z; + r_val.w = aa.w * bb.w; return r_val; } #endif @@ -724,13 +830,48 @@ namespace KokkosBatched { } #if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__) + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) + operator / (const Vector,2> &a, const Vector,2> &b) { + const float2 aa(a), bb(b); + /* */ float2 r_val; + r_val.x = aa.x / bb.x; + r_val.y = aa.y / bb.y; + return r_val; + } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator / (const Vector,2> &a, const Vector,2> &b) { - double2 r_val; - r_val.x = a.double2().x / b.double2().x; - r_val.y = a.double2().y / b.double2().y; + const double2 aa(a), bb(b); + /* */ double2 r_val; + r_val.x = aa.x / bb.x; + r_val.y = aa.y / bb.y; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) + operator / (const Vector,4> &a, const Vector,4> &b) { + const float4 aa(a), bb(b); + /* */ float4 r_val; + r_val.x = aa.x / bb.x; + r_val.y = aa.y / bb.y; + r_val.z = aa.z / bb.z; + r_val.w = aa.w / bb.w; + return r_val; + } + KOKKOS_FORCEINLINE_FUNCTION + static + KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) + operator / (const Vector,4> &a, const Vector,4> &b) { + const double4 aa(a), bb(b); + /* */ double4 r_val; + r_val.x = aa.x / bb.x; + r_val.y = aa.y / bb.y; + r_val.z = aa.z / bb.z; + r_val.w = aa.w / bb.w; return r_val; } #endif From 4d15613343a5e275922b5dd84595b7e1b65b4804 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Thu, 16 May 2019 11:11:44 -0600 Subject: [PATCH 180/190] KokkosBatched - adding pragma simd for a more portable way of vectorization the pragma should work even for arm if the compiler support it. --- src/batched/KokkosBatched_Vector_SIMD.hpp | 36 +++++++++++++++++++ .../KokkosBatched_Vector_SIMD_Arith.hpp | 15 ++++++++ 2 files changed, 51 insertions(+) diff --git a/src/batched/KokkosBatched_Vector_SIMD.hpp b/src/batched/KokkosBatched_Vector_SIMD.hpp index 204d614d14..035629019a 100644 --- a/src/batched/KokkosBatched_Vector_SIMD.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD.hpp @@ -44,6 +44,9 @@ namespace KokkosBatched { #endif #if defined( KOKKOS_ENABLE_PRAGMA_VECTOR ) #pragma vector always +#endif +#if defined( KOKKOS_ENABLE_OPENMP ) && !defined(__CUDA_ARCH__) +#pragma omp simd #endif for (int i=0;i Date: Thu, 16 May 2019 16:00:14 -0600 Subject: [PATCH 181/190] do-not-use: Update fences for compatibility --- .../KokkosBatched_Test_Gemm_Cuda.cpp | 26 +++++++++---------- .../do-not-use/KokkosBatched_Test_LU_Cuda.cpp | 24 ++++++++--------- .../KokkosBatched_Test_Trsm_Cuda.cpp | 22 ++++++++-------- 3 files changed, 36 insertions(+), 36 deletions(-) diff --git a/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp index bfb6d3d0f4..3fcb6ebb6a 100644 --- a/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp +++ b/perf_test/batched/do-not-use/KokkosBatched_Test_Gemm_Cuda.cpp @@ -228,7 +228,7 @@ namespace KokkosBatched { Kokkos::deep_copy(amat_device, amat); Kokkos::deep_copy(bmat_device, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); const double one(1.0), zero(0.0); { @@ -243,7 +243,7 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat_device); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); stat = cublasDgemmStridedBatched(handle, @@ -257,7 +257,7 @@ namespace KokkosBatched { (value_type*)c.data(), BlkSize, BlkSize*BlkSize, N*VectorLength); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -306,12 +306,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::RangeTag", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -373,12 +373,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV1", policy,functor_type(a,b,c)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -446,12 +446,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV2", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -523,12 +523,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyV3", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -595,12 +595,12 @@ namespace KokkosBatched { Kokkos::deep_copy(b, bmat); Kokkos::deep_copy(c, 0); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::GemmCuda::TeamPolicyHandmade", policy, functor_type(a,b,c)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp index 4c2da01804..065e8cceb0 100644 --- a/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp +++ b/perf_test/batched/do-not-use/KokkosBatched_Test_LU_Cuda.cpp @@ -198,7 +198,7 @@ namespace KokkosBatched { auto amat_device = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), amat); Kokkos::deep_copy(amat_device, amat); - DeviceSpaceType::fence(); + Kokkos::fence(); { double tavg = 0, tmin = tmax; value_type *aa[N*VectorLength]; @@ -213,7 +213,7 @@ namespace KokkosBatched { if (cudaMemcpy(aa_device, aa, sizeof(value_type*)*N*VectorLength, cudaMemcpyHostToDevice) != cudaSuccess) { Kokkos::abort("CUDA memcpy failed\n"); } - DeviceSpaceType::fence(); + Kokkos::fence(); for (int iter=iter_begin;iter= 0)*t; @@ -282,12 +282,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::RangeTag", policy, functor_type(a)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -341,12 +341,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV1", policy, functor_type(a)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -410,12 +410,12 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV2", policy, functor_type(a)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -482,13 +482,13 @@ namespace KokkosBatched { // initialize matrix Kokkos::deep_copy(a, amat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::LUCuda::TeamTagV3", policy.set_scratch_size(lvl, Kokkos::PerTeam(per_team_scratch)), functor_type(a)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; diff --git a/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp b/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp index d13bb215b5..ccaede5aba 100644 --- a/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp +++ b/perf_test/batched/do-not-use/KokkosBatched_Test_Trsm_Cuda.cpp @@ -311,7 +311,7 @@ namespace KokkosBatched { Kokkos::deep_copy(amat_device, amat); Kokkos::deep_copy(bmat_device, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); const double one(1.0); //, zero(0.0); { @@ -334,7 +334,7 @@ namespace KokkosBatched { cudaMemcpy(bb_device, bb, sizeof(value_type*)*N*VectorLength, cudaMemcpyHostToDevice) != cudaSuccess) { Kokkos::abort("CUDA memcpy failed\n"); } - DeviceSpaceType::fence(); + Kokkos::fence(); for (int iter=iter_begin;iter= 0)*t; @@ -473,12 +473,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::RangeTag", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -536,12 +536,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV1", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -608,12 +608,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV2", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; @@ -685,12 +685,12 @@ namespace KokkosBatched { Kokkos::deep_copy(a, amat); Kokkos::deep_copy(b, bmat); - DeviceSpaceType::fence(); + Kokkos::fence(); timer.reset(); Kokkos::parallel_for("KokkosBatched::PerfTest::TeamTagV3", policy, functor_type(a, b)); - DeviceSpaceType::fence(); + Kokkos::fence(); const double t = timer.seconds(); tmin = std::min(tmin, t); tavg += (iter >= 0)*t; From eec7b07d5972edfcc8e12dc4357169d612de4d47 Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Fri, 17 May 2019 10:23:56 -0600 Subject: [PATCH 182/190] KokkosBatched - fix cuda builtin type conversion --- .../KokkosBatched_Vector_SIMD_Arith.hpp | 144 ++++++++---------- 1 file changed, 64 insertions(+), 80 deletions(-) diff --git a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp index eae07cfec0..ab4a8c4f6c 100644 --- a/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp +++ b/src/batched/KokkosBatched_Vector_SIMD_Arith.hpp @@ -76,44 +76,40 @@ namespace KokkosBatched { static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) operator + (const Vector,2> &a, const Vector,2> &b) { - const float2 aa(a), bb(b); - /* */ float2 r_val; - r_val.x = aa.x + bb.x; - r_val.y = aa.y + bb.y; + float2 r_val; + r_val.x = a.float2().x + b.float2().x; + r_val.y = a.float2().y + b.float2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator + (const Vector,2> &a, const Vector,2> &b) { - const double2 aa(a), bb(b); - /* */ double2 r_val; - r_val.x = aa.x + bb.x; - r_val.y = aa.y + bb.y; + double2 r_val; + r_val.x = a.double2().x + b.double2().x; + r_val.y = a.double2().y + b.double2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) operator + (const Vector,4> &a, const Vector,4> &b) { - const float4 aa(a), bb(b); - /* */ float4 r_val; - r_val.x = aa.x + bb.x; - r_val.y = aa.y + bb.y; - r_val.z = aa.z + bb.z; - r_val.w = aa.w + bb.w; + float4 r_val; + r_val.x = a.float4().x + b.float4().x; + r_val.y = a.float4().y + b.float4().y; + r_val.z = a.float4().z + b.float4().z; + r_val.w = a.float4().w + b.float4().w; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator + (const Vector,4> &a, const Vector,4> &b) { - const double4 aa(a), bb(b); - /* */ double4 r_val; - r_val.x = aa.x + bb.x; - r_val.y = aa.y + bb.y; - r_val.z = aa.z + bb.z; - r_val.w = aa.w + bb.w; + double4 r_val; + r_val.x = a.double4().x + b.double4().x; + r_val.y = a.double4().y + b.double4().y; + r_val.z = a.double4().z + b.double4().z; + r_val.w = a.double4().w + b.double4().w; return r_val; } @@ -296,44 +292,40 @@ namespace KokkosBatched { static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) operator - (const Vector,2> &a, const Vector,2> &b) { - const float2 aa(a), bb(b); - /* */ float2 r_val; - r_val.x = aa.x - bb.x; - r_val.y = aa.y - bb.y; + float2 r_val; + r_val.x = a.float2().x - b.float2().x; + r_val.y = a.float2().y - b.float2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator - (const Vector,2> &a, const Vector,2> &b) { - const double2 aa(a), bb(b); - /* */ double2 r_val; - r_val.x = aa.x - bb.x; - r_val.y = aa.y - bb.y; + double2 r_val; + r_val.x = a.double2().x - b.double2().x; + r_val.y = a.double2().y - b.double2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) operator - (const Vector,4> &a, const Vector,4> &b) { - const float4 aa(a), bb(b); - /* */ float4 r_val; - r_val.x = aa.x - bb.x; - r_val.y = aa.y - bb.y; - r_val.z = aa.z - bb.z; - r_val.w = aa.w - bb.w; + float4 r_val; + r_val.x = a.float4().x - b.float4().x; + r_val.y = a.float4().y - b.float4().y; + r_val.z = a.float4().z - b.float4().z; + r_val.w = a.float4().w - b.float4().w; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator - (const Vector,4> &a, const Vector,4> &b) { - const double4 aa(a), bb(b); - /* */ double4 r_val; - r_val.x = aa.x - bb.x; - r_val.y = aa.y - bb.y; - r_val.z = aa.z - bb.z; - r_val.w = aa.w - bb.w; + double4 r_val; + r_val.x = a.double4().x - b.double4().x; + r_val.y = a.double4().y - b.double4().y; + r_val.z = a.double4().z - b.double4().z; + r_val.w = a.double4().w - b.double4().w; return r_val; } #endif @@ -560,44 +552,40 @@ namespace KokkosBatched { static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) operator * (const Vector,2> &a, const Vector,2> &b) { - const float2 aa(a), bb(b); - /* */ float2 r_val; - r_val.x = aa.x * bb.x; - r_val.y = aa.y * bb.y; + float2 r_val; + r_val.x = a.float2().x * b.float2().x; + r_val.y = a.float2().y * b.float2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator * (const Vector,2> &a, const Vector,2> &b) { - const double2 aa(a), bb(b); - /* */ double2 r_val; - r_val.x = aa.x * bb.x; - r_val.y = aa.y * bb.y; + double2 r_val; + r_val.x = a.double2().x * b.double2().x; + r_val.y = a.double2().y * b.double2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) operator * (const Vector,4> &a, const Vector,4> &b) { - const float4 aa(a), bb(b); - /* */ float4 r_val; - r_val.x = aa.x * bb.x; - r_val.y = aa.y * bb.y; - r_val.z = aa.z * bb.z; - r_val.w = aa.w * bb.w; + float4 r_val; + r_val.x = a.float4().x * b.float4().x; + r_val.y = a.float4().y * b.float4().y; + r_val.z = a.float4().z * b.float4().z; + r_val.w = a.float4().w * b.float4().w; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator * (const Vector,4> &a, const Vector,4> &b) { - const double4 aa(a), bb(b); - /* */ double4 r_val; - r_val.x = aa.x * bb.x; - r_val.y = aa.y * bb.y; - r_val.z = aa.z * bb.z; - r_val.w = aa.w * bb.w; + double4 r_val; + r_val.x = a.double4().x * b.double4().x; + r_val.y = a.double4().y * b.double4().y; + r_val.z = a.double4().z * b.double4().z; + r_val.w = a.double4().w * b.double4().w; return r_val; } #endif @@ -849,44 +837,40 @@ namespace KokkosBatched { static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,2) operator / (const Vector,2> &a, const Vector,2> &b) { - const float2 aa(a), bb(b); - /* */ float2 r_val; - r_val.x = aa.x / bb.x; - r_val.y = aa.y / bb.y; + float2 r_val; + r_val.x = a.float2().x / b.float2().x; + r_val.y = a.float2().y / b.float2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,2) operator / (const Vector,2> &a, const Vector,2> &b) { - const double2 aa(a), bb(b); - /* */ double2 r_val; - r_val.x = aa.x / bb.x; - r_val.y = aa.y / bb.y; + double2 r_val; + r_val.x = a.double2().x / b.double2().x; + r_val.y = a.double2().y / b.double2().y; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(float,4) operator / (const Vector,4> &a, const Vector,4> &b) { - const float4 aa(a), bb(b); - /* */ float4 r_val; - r_val.x = aa.x / bb.x; - r_val.y = aa.y / bb.y; - r_val.z = aa.z / bb.z; - r_val.w = aa.w / bb.w; + float4 r_val; + r_val.x = a.float4().x / b.float4().x; + r_val.y = a.float4().y / b.float4().y; + r_val.z = a.float4().z / b.float4().z; + r_val.w = a.float4().w / b.float4().w; return r_val; } KOKKOS_FORCEINLINE_FUNCTION static KOKKOSKERNELS_SIMD_ARITH_RETURN_TYPE(double,4) operator / (const Vector,4> &a, const Vector,4> &b) { - const double4 aa(a), bb(b); - /* */ double4 r_val; - r_val.x = aa.x / bb.x; - r_val.y = aa.y / bb.y; - r_val.z = aa.z / bb.z; - r_val.w = aa.w / bb.w; + double4 r_val; + r_val.x = a.double4().x / b.double4().x; + r_val.y = a.double4().y / b.double4().y; + r_val.z = a.double4().z / b.double4().z; + r_val.w = a.double4().w / b.double4().w; return r_val; } #endif From 35c6d35f05cc003ce4e8191068b500aae85c9800 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Tue, 28 May 2019 10:23:01 -0600 Subject: [PATCH 183/190] Fix -Werror in gesv tpl avail check -Werror triggered due to multi-line comment, fixed with this PR. Changes to be committed: modified: KokkosBlas_gesv_tpl_spec_avail.hpp --- .../tpls/KokkosBlas_gesv_tpl_spec_avail.hpp | 35 ++++++++++--------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp index fec7b97782..441f6f7171 100644 --- a/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp +++ b/src/impl/tpls/KokkosBlas_gesv_tpl_spec_avail.hpp @@ -82,23 +82,24 @@ struct gesv_tpl_spec_avail< \ KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutLeft, Kokkos::CudaSpace) #endif -//#if defined (KOKKOSKERNELS_INST_DOUBLE) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_FLOAT) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex,Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif -//#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ -// && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) -// KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutRight, Kokkos::CudaSpace) -//#endif - +/* +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( double, Kokkos::LayoutRight, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( float, Kokkos::LayoutRight, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex,Kokkos::LayoutRight, Kokkos::CudaSpace) +#endif +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) + KOKKOSBLAS_GESV_TPL_SPEC_AVAIL_MAGMA( Kokkos::complex, Kokkos::LayoutRight, Kokkos::CudaSpace) +#endif +*/ #endif } From bb7b6d9cad74c6aa36aaaab66cebb9deb5984b7b Mon Sep 17 00:00:00 2001 From: Kyungjoo Kim Date: Fri, 31 May 2019 11:13:35 -0600 Subject: [PATCH 184/190] KokkosBatched - reduce vector length from 16 to 8. Most important part in memory efficiency is keeping 32 byte cacheline. By reducing the length, we can increase occupancy for smaller problems and sparc is the case. --- src/batched/KokkosBatched_Vector.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/batched/KokkosBatched_Vector.hpp b/src/batched/KokkosBatched_Vector.hpp index fe711444f7..9206372e08 100644 --- a/src/batched/KokkosBatched_Vector.hpp +++ b/src/batched/KokkosBatched_Vector.hpp @@ -64,35 +64,35 @@ namespace KokkosBatched { #if defined(KOKKOS_ENABLE_CUDA) template<> struct DefaultVectorLength { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength,Kokkos::CudaSpace> { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength,Kokkos::CudaSpace> { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 16 }; + enum : int { value = 8 }; }; template<> struct DefaultVectorLength,Kokkos::CudaUVMSpace> { - enum : int { value = 16 }; + enum : int { value = 8 }; }; #endif From 97129d0188046912e6ed51943424c149f2fd0187 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Wed, 29 May 2019 15:39:48 -0600 Subject: [PATCH 185/190] sptrsv: Kokkos-based sparse trisolve routines First commit with sparse triangular handle, symbolic, and solve routines. All components are in Experimental namespace to allow for changes while algorithms under development. sptrsv: Disable TP2 alg in Cuda tests Issues with non-int-int ordinal-offset combos with Cuda. Algorithm primarily serves as skeleton for 3-level parallelism and future development --- perf_test/sparse/CMakeLists.txt | 4 + perf_test/sparse/KokkosSparse_sptrsv.cpp | 660 +++++ scripts/generate_specialization.bash | 5 +- src/common/KokkosKernels_Handle.hpp | 33 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...ble__int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...le__int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...e__int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...le__int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...e__int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...e__int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...__int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...le__int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...e__int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...e__int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...__int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...oat__int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...at__int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...t__int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...at__int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...t__int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...t__int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...__int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...at__int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...t__int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...t__int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...__int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...uble_int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...e_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...ble_int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...le_int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...ble_int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...le_int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...le_int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...e_int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...ble_int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...le_int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...e_int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...le_int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...e_int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...e_int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...e_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...loat_int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...oat_int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...at_int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...oat_int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...at_int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...at_int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...oat_int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...at_int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...at_int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...t_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...ble__int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...le__int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...e__int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...le__int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...e__int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...e__int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...__int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...le__int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...e__int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...e__int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...__int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...oat__int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...at__int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...t__int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...at__int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...t__int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...t__int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...__int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...at__int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...t__int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...t__int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...__int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...__int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...uble_int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...e_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...ble_int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...le_int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...ble_int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...le_int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...le_int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...e_int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...ble_int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...le_int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...e_int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...le_int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...e_int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...e_int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...e_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ..._int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...int_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ...nt_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...int_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...nt_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...nt_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...loat_int_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...oat_int_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...at_int_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...oat_int_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...at_int_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...at_int_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ...oat_int_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...at_int_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...at_int_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...ze_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Serial_HostSpace.cpp | 60 + ..._t_int64_t_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...t_int64_t_LayoutLeft_Threads_HostSpace.cpp | 60 + ...e_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp | 60 + ..._int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ..._t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_OpenMP_HostSpace.cpp | 60 + ..._t_int64_t_LayoutRight_Serial_HBWSpace.cpp | 60 + ...t_int64_t_LayoutRight_Serial_HostSpace.cpp | 60 + ...t_int64_t_LayoutRight_Threads_HBWSpace.cpp | 60 + ..._int64_t_LayoutRight_Threads_HostSpace.cpp | 60 + ...t_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp | 60 + ..._size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_OpenMP_HostSpace.cpp | 60 + ..._size_t_int_LayoutLeft_Serial_HBWSpace.cpp | 60 + ...size_t_int_LayoutLeft_Serial_HostSpace.cpp | 60 + ...size_t_int_LayoutLeft_Threads_HBWSpace.cpp | 60 + ...ize_t_int_LayoutLeft_Threads_HostSpace.cpp | 60 + ..._size_t_int_LayoutRight_Cuda_CudaSpace.cpp | 60 + ...ze_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp | 60 + ...size_t_int_LayoutRight_OpenMP_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_OpenMP_HostSpace.cpp | 60 + ...size_t_int_LayoutRight_Serial_HBWSpace.cpp | 60 + ...ize_t_int_LayoutRight_Serial_HostSpace.cpp | 60 + ...ize_t_int_LayoutRight_Threads_HBWSpace.cpp | 60 + ...ze_t_int_LayoutRight_Threads_HostSpace.cpp | 60 + ...kkosSparse_sptrsv_solve_eti_spec_avail.hpp | 2354 +++++++++++++++++ ...okkosSparse_sptrsv_solve_eti_spec_decl.hpp | 2354 +++++++++++++++++ ...sSparse_sptrsv_symbolic_eti_spec_avail.hpp | 2354 +++++++++++++++++ ...osSparse_sptrsv_symbolic_eti_spec_decl.hpp | 2354 +++++++++++++++++ ...kkosSparse_sptrsv_solve_tpl_spec_avail.hpp | 64 + ...okkosSparse_sptrsv_solve_tpl_spec_decl.hpp | 52 + ...sSparse_sptrsv_symbolic_tpl_spec_avail.hpp | 61 + ...osSparse_sptrsv_symbolic_tpl_spec_decl.hpp | 52 + src/sparse/KokkosSparse_sptrsv.hpp | 223 ++ src/sparse/KokkosSparse_sptrsv_handle.hpp | 261 ++ .../impl/KokkosSparse_sptrsv_solve_impl.hpp | 684 +++++ .../impl/KokkosSparse_sptrsv_solve_spec.hpp | 236 ++ .../KokkosSparse_sptrsv_symbolic_impl.hpp | 293 ++ .../KokkosSparse_sptrsv_symbolic_spec.hpp | 182 ++ unit_test/Makefile | 4 + unit_test/cuda/Test_Cuda_Sparse_sptrsv.cpp | 2 + .../openmp/Test_OpenMP_Sparse_sptrsv.cpp | 2 + .../serial/Test_Serial_Sparse_sptrsv.cpp | 2 + unit_test/sparse/Test_Sparse_sptrsv.hpp | 703 +++++ .../threads/Test_Threads_Sparse_sptrsv.cpp | 2 + 536 files changed, 43660 insertions(+), 1 deletion(-) create mode 100644 perf_test/sparse/KokkosSparse_sptrsv.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp create mode 100644 src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp create mode 100644 src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_avail.hpp create mode 100644 src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_decl.hpp create mode 100644 src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_avail.hpp create mode 100644 src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_decl.hpp create mode 100644 src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_avail.hpp create mode 100644 src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_decl.hpp create mode 100644 src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_avail.hpp create mode 100644 src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_decl.hpp create mode 100644 src/sparse/KokkosSparse_sptrsv.hpp create mode 100644 src/sparse/KokkosSparse_sptrsv_handle.hpp create mode 100644 src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp create mode 100644 src/sparse/impl/KokkosSparse_sptrsv_solve_spec.hpp create mode 100644 src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp create mode 100644 src/sparse/impl/KokkosSparse_sptrsv_symbolic_spec.hpp create mode 100644 unit_test/cuda/Test_Cuda_Sparse_sptrsv.cpp create mode 100644 unit_test/openmp/Test_OpenMP_Sparse_sptrsv.cpp create mode 100644 unit_test/serial/Test_Serial_Sparse_sptrsv.cpp create mode 100644 unit_test/sparse/Test_Sparse_sptrsv.hpp create mode 100644 unit_test/threads/Test_Threads_Sparse_sptrsv.cpp diff --git a/perf_test/sparse/CMakeLists.txt b/perf_test/sparse/CMakeLists.txt index 2c1c76e533..d2b2235334 100644 --- a/perf_test/sparse/CMakeLists.txt +++ b/perf_test/sparse/CMakeLists.txt @@ -18,6 +18,10 @@ TRIBITS_ADD_EXECUTABLE( SOURCES KokkosSparse_spmv.cpp ) +TRIBITS_ADD_EXECUTABLE( + sparse_sptrsv + SOURCES KokkosSparse_sptrsv.cpp + ) diff --git a/perf_test/sparse/KokkosSparse_sptrsv.cpp b/perf_test/sparse/KokkosSparse_sptrsv.cpp new file mode 100644 index 0000000000..1f86a17a52 --- /dev/null +++ b/perf_test/sparse/KokkosSparse_sptrsv.cpp @@ -0,0 +1,660 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#include + +#include +#include +#include +#include +#include +#include +#include + +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE +#include +#endif + +#include +#include + +#include "KokkosKernels_SparseUtils.hpp" +#include "KokkosSparse_sptrsv.hpp" +#include "KokkosSparse_spmv.hpp" +#include "KokkosSparse_CrsMatrix.hpp" +#include + +#if defined( KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA ) && (!defined(KOKKOS_ENABLE_CUDA) || ( 8000 <= CUDA_VERSION )) +using namespace KokkosSparse; +using namespace KokkosSparse::Experimental; +using namespace KokkosKernels; +using namespace KokkosKernels::Experimental; + +enum {DEFAULT, CUSPARSE, LVLSCHED_RP, LVLSCHED_TP1, LVLSCHED_TP2}; + + + +template +int test_sptrsv_perf(std::vector tests, std::string& lfilename, std::string& ufilename, int team_size, int vector_length, int idx_offset, int loop) { + + typedef Scalar scalar_t; + typedef int lno_t; + typedef int size_type; + typedef Kokkos::DefaultExecutionSpace execution_space; + typedef typename execution_space::memory_space memory_space; + + typedef KokkosSparse::CrsMatrix crsmat_t; + typedef typename crsmat_t::StaticCrsGraphType graph_t; + + typedef Kokkos::View< scalar_t*, memory_space > ValuesType; + + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + + scalar_t ZERO = scalar_t(0); + scalar_t ONE = scalar_t(1); + + +// Read lmtx +// Run all requested algorithms +// Read umtx +// Run all requested algorithms + +// LOWERTRI + std::cout << "\n\n" << std::endl; + if (!lfilename.empty()) + { + std::cout << "Lower Tri Begin: Read matrix filename " << lfilename << std::endl; + crsmat_t triMtx = KokkosKernels::Impl::read_kokkos_crst_matrix(lfilename.c_str()); //in_matrix + graph_t graph = triMtx.graph; // in_graph + const size_type nrows = graph.numRows(); + + // Create the rhs and lhs_known solution + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + + std::cout << "SPMV" << std::endl; + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + + auto row_map = graph.row_map; + auto entries = graph.entries; + auto values = triMtx.values; + + + +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE + //std::cout << " cusparse: create handle" << std::endl; + cusparseStatus_t status; + cusparseHandle_t handle = 0; + status = cusparseCreate(&handle); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "handle create status error name " << (status) << std::endl; + cusparseSetPointerMode(handle, CUSPARSE_POINTER_MODE_HOST); + cusparseMatDescr_t descr = 0; + csrsv2Info_t info = 0; + int pBufferSize; + void *pBuffer = 0; + int structural_zero; + int numerical_zero; + const double alpha = 1.; + const cusparseSolvePolicy_t policy = CUSPARSE_SOLVE_POLICY_USE_LEVEL; + const cusparseOperation_t trans = CUSPARSE_OPERATION_NON_TRANSPOSE; + + // step 1: create a descriptor which contains + // - matrix L is lower triangular + // (L may not have all diagonal elements.) + status = cusparseCreateMatDescr(&descr); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "matdescr create status error name " << (status) << std::endl; + //cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ONE); + cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ZERO); + cusparseSetMatFillMode(descr, CUSPARSE_FILL_MODE_LOWER); + cusparseSetMatDiagType(descr, CUSPARSE_DIAG_TYPE_NON_UNIT); + cusparseSetMatType(descr,CUSPARSE_MATRIX_TYPE_GENERAL); + //cusparseSetMatDiagType(descr, CUSPARSE_DIAG_TYPE_UNIT); + + // step 2: create a empty info structure + //std::cout << " cusparse: create csrsv2info" << std::endl; + status = cusparseCreateCsrsv2Info(&info); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "csrsv2info create status error name " << (status) << std::endl; + + // step 3: query how much memory used in csrsv2, and allocate the buffer + int nnz = triMtx.nnz(); + cusparseDcsrsv2_bufferSize(handle, trans, nrows, nnz, descr, + values.data(), row_map.data(), entries.data(), info, &pBufferSize); + // pBuffer returned by cudaMalloc is automatically aligned to 128 bytes. + cudaMalloc((void**)&pBuffer, pBufferSize); +#endif + + + for ( auto test : tests ) { + std::cout << "\ntest = " << test << std::endl; + + KernelHandle kh; + bool is_lower_tri = true; + + std::cout << "Create handle" << std::endl; + switch(test) { + case LVLSCHED_RP: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_RP, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; + case LVLSCHED_TP1: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; + case LVLSCHED_TP2: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHED_TP2, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE + case CUSPARSE: + std::cout << "CUSPARSE: No kk interface added yet" << std::endl; + //cusparse_matvec(A, x, y, rows_per_thread, team_size, vector_length); + break; +#endif + default: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + } + + + // Init run to clear cache etc. + Kokkos::Timer timer; + if (test != CUSPARSE) { + timer.reset(); + sptrsv_symbolic( &kh, row_map, entries ); + std::cout << "LTRI Symbolic Time: " << timer.seconds() << std::endl; + + //std::cout << "TriSolve Solve" << std::endl; + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + std::cout << "LTRI Solve Time: " << timer.seconds() << std::endl; + + } +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE +// step 4: perform analysis + else { +#if 0 + double *dvalues = (double *)(values.data()); + int *drow_map = (int *)(row_map.data()); + int *dentries = (int *)(entries.data()); + double *dlhs = (double *)(lhs.data()); + double *drhs = (double *)(rhs.data()); +#endif + //int nnz = triMtx.nnz(); + //std::cout << " cusparse path: analysis" << std::endl; + //status = cusparseDcsrsv2_analysis(handle, trans, nrows, nnz, descr, (double*)dvalues, (int *)drow_map, (int *)dentries, info, policy, pBuffer); + timer.reset(); + status = cusparseDcsrsv2_analysis(handle, trans, nrows, triMtx.nnz(), descr, values.data(), row_map.data(), entries.data(), info, policy, pBuffer); + std::cout << "LTRI Cusparse Symbolic Time: " << timer.seconds() << std::endl; + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "analysis status error name " << (status) << std::endl; +// L has unit diagonal, so no structural zero is reported. + + //std::cout << " cusparse path: analysis" << std::endl; + status = cusparseXcsrsv2_zeroPivot(handle, info, &structural_zero); + if (CUSPARSE_STATUS_ZERO_PIVOT == status){ + printf("L(%d,%d) is missing\n", structural_zero, structural_zero); + } + +// step 5: solve L*y = x + //std::cout << " cusparse path: solve" << std::endl; + //status = cusparseDcsrsv2_solve(handle, trans, nrows, nnz, &alpha, descr, (double*)dvalues, (int *)drow_map, (int *)dentries, info, (double*)drhs, (double*)dlhs, policy, pBuffer); + timer.reset(); + status = cusparseDcsrsv2_solve(handle, trans, nrows, triMtx.nnz(), &alpha, descr, values.data(), row_map.data(), entries.data(), info, rhs.data(), lhs.data(), policy, pBuffer); + Kokkos::fence(); + std::cout << "LTRI Cusparse Solve Time: " << timer.seconds() << std::endl; + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "solve status error name " << (status) << std::endl; +// L has unit diagonal, so no numerical zero is reported. + status = cusparseXcsrsv2_zeroPivot(handle, info, &numerical_zero); + if (CUSPARSE_STATUS_ZERO_PIVOT == status){ + printf("L(%d,%d) is zero\n", numerical_zero, numerical_zero); + } + } +#endif + // Error Check + scalar_t sum = 0.0; + Kokkos::fence(); + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), + KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE: sum = " << sum << std::endl; + auto hsoln = Kokkos::create_mirror_view(lhs); + Kokkos::deep_copy(hsoln, lhs); + for ( size_t i = 0; i < hsoln.extent(0); ++i ) { + std::cout << "lhs(" << i << ") = " << hsoln(i) << std::endl; + } + return 1; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + } + + + // Benchmark + Kokkos::fence(); + double min_time = 1.0e32; + double max_time = 0.0; + double ave_time = 0.0; + + for(int i=0;imax_time) max_time = time; + if(time(ufilename.c_str()); //in_matrix + graph_t graph = triMtx.graph; // in_graph + const size_type nrows = graph.numRows(); + + // Create the rhs and lhs_known solution + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + + std::cout << "SPMV" << std::endl; + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + auto row_map = graph.row_map; + auto entries = graph.entries; + auto values = triMtx.values; + +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE + //std::cout << " cusparse: create handle" << std::endl; + cusparseStatus_t status; + cusparseHandle_t handle = 0; + status = cusparseCreate(&handle); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "handle create status error name " << (status) << std::endl; + cusparseSetPointerMode(handle, CUSPARSE_POINTER_MODE_HOST); + cusparseMatDescr_t descr = 0; + csrsv2Info_t info = 0; + int pBufferSize; + void *pBuffer = 0; + int structural_zero; + int numerical_zero; + const double alpha = 1.; + const cusparseSolvePolicy_t policy = CUSPARSE_SOLVE_POLICY_USE_LEVEL; + const cusparseOperation_t trans = CUSPARSE_OPERATION_NON_TRANSPOSE; + + // step 1: create a descriptor which contains + // (L may not have all diagonal elements.) + status = cusparseCreateMatDescr(&descr); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "matdescr create status error name " << (status) << std::endl; + //cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ONE); + cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ZERO); + cusparseSetMatFillMode(descr, CUSPARSE_FILL_MODE_UPPER); + cusparseSetMatDiagType(descr, CUSPARSE_DIAG_TYPE_NON_UNIT); + cusparseSetMatType(descr,CUSPARSE_MATRIX_TYPE_GENERAL); + //cusparseSetMatType(descr,CUSPARSE_MATRIX_TYPE_TRIANGULAR); + //cusparseSetMatDiagType(descr, CUSPARSE_DIAG_TYPE_UNIT); + + // step 2: create a empty info structure + //std::cout << " cusparse: create csrsv2info" << std::endl; + status = cusparseCreateCsrsv2Info(&info); + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "csrsv2info create status error name " << (status) << std::endl; + + // step 3: query how much memory used in csrsv2, and allocate the buffer + int nnz = triMtx.nnz(); + cusparseDcsrsv2_bufferSize(handle, trans, nrows, nnz, descr, + values.data(), row_map.data(), entries.data(), info, &pBufferSize); + // pBuffer returned by cudaMalloc is automatically aligned to 128 bytes. + cudaMalloc((void**)&pBuffer, pBufferSize); +#endif + + + for ( auto test : tests ) { + std::cout << "\ntest = " << test << std::endl; + + KernelHandle kh; + bool is_lower_tri = false; + + std::cout << "Create handle" << std::endl; + switch(test) { + case LVLSCHED_RP: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_RP, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; + case LVLSCHED_TP1: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; + case LVLSCHED_TP2: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHED_TP2, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + break; +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE + case CUSPARSE: + std::cout << "CUSPARSE: No kk interface added yet" << std::endl; + //cusparse_matvec(A, x, y, rows_per_thread, team_size, vector_length); + break; +#endif + default: + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + kh.get_sptrsv_handle()->print_algorithm(); + } + + + // Init run to clear cache etc. + Kokkos::Timer timer; + if (test != CUSPARSE) { + timer.reset(); + sptrsv_symbolic( &kh, row_map, entries ); + std::cout << "UTRI Symbolic Time: " << timer.seconds() << std::endl; + + //std::cout << "TriSolve Solve" << std::endl; + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + std::cout << "UTRI Solve Time: " << timer.seconds() << std::endl; + + } +#ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE +// step 4: perform analysis + else { +#if 0 + double *dvalues = (double *)(values.data()); + int *drow_map = (int *)(row_map.data()); + int *dentries = (int *)(entries.data()); + double *dlhs = (double *)(lhs.data()); + double *drhs = (double *)(rhs.data()); +#endif + //int nnz = triMtx.nnz(); + //std::cout << " cusparse path: analysis" << std::endl; + //status = cusparseDcsrsv2_analysis(handle, trans, nrows, nnz, descr, (double*)dvalues, (int *)drow_map, (int *)dentries, info, policy, pBuffer); + timer.reset(); + status = cusparseDcsrsv2_analysis(handle, trans, nrows, triMtx.nnz(), descr, values.data(), row_map.data(), entries.data(), info, policy, pBuffer); + std::cout << "UTRI Cusparse Symbolic Time: " << timer.seconds() << std::endl; + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "analysis status error name " << (status) << std::endl; + // L has unit diagonal, so no structural zero is reported. + + status = cusparseXcsrsv2_zeroPivot(handle, info, &structural_zero); + if (CUSPARSE_STATUS_ZERO_PIVOT == status){ + printf("L(%d,%d) is missing\n", structural_zero, structural_zero); + } + +// step 5: solve L*y = x + //std::cout << " cusparse path: solve" << std::endl; + //status = cusparseDcsrsv2_solve(handle, trans, nrows, nnz, &alpha, descr, (double*)dvalues, (int *)drow_map, (int *)dentries, info, (double*)drhs, (double*)dlhs, policy, pBuffer); + timer.reset(); + status = cusparseDcsrsv2_solve(handle, trans, nrows, triMtx.nnz(), &alpha, descr, values.data(), row_map.data(), entries.data(), info, rhs.data(), lhs.data(), policy, pBuffer); + Kokkos::fence(); + std::cout << "UTRI Cusparse Solve Time: " << timer.seconds() << std::endl; + if (CUSPARSE_STATUS_SUCCESS != status) + std::cout << "solve status error name " << (status) << std::endl; + // L has unit diagonal, so no numerical zero is reported. + status = cusparseXcsrsv2_zeroPivot(handle, info, &numerical_zero); + if (CUSPARSE_STATUS_ZERO_PIVOT == status){ + printf("L(%d,%d) is zero\n", numerical_zero, numerical_zero); + } + } +#endif + // Error Check + Kokkos::fence(); + scalar_t sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), + KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + + if ( sum != scalar_t(lhs.extent(0)) ) { + std::cout << "Upper Tri Solve FAILURE: sum = " << sum << std::endl; + auto hsoln = Kokkos::create_mirror_view(lhs); + Kokkos::deep_copy(hsoln, lhs); + for ( size_t i = 0; i < hsoln.extent(0); ++i ) { + std::cout << "lhs(" << i << ") = " << hsoln(i) << std::endl; + } + return 1; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + } + + // Benchmark + Kokkos::fence(); + double min_time = 1.0e32; + double max_time = 0.0; + double ave_time = 0.0; + + for(int i=0;imax_time) max_time = time; + if(time tests; + + std::string lfilename; + std::string ufilename; + + int vector_length = -1; + int team_size = -1; + int idx_offset = 0; + int loop = 1; +// int schedule=AUTO; + + if(argc == 1) { + print_help_sptrsv(); + return 0; + } + + for(int i=0;igsHandle = right_side_handle.get_gs_handle(); this->spgemmHandle = right_side_handle.get_spgemm_handle(); + this->sptrsvHandle = right_side_handle.get_sptrsv_handle(); + this->team_work_size = right_side_handle.get_set_team_work_size(); this->shared_memory_size = right_side_handle.get_shmem_size(); this->suggested_team_size = right_side_handle.get_set_suggested_team_size(); @@ -150,6 +153,7 @@ class KokkosKernelsHandle is_owner_of_the_gs_handle = false; is_owner_of_the_spgemm_handle = false; is_owner_of_the_spadd_handle = false; + is_owner_of_the_sptrsv_handle = false; //return *this; } @@ -190,6 +194,9 @@ class KokkosKernelsHandle typename KokkosSparse::SPADDHandle SPADDHandleType; + typedef + typename KokkosSparse::Experimental::SPTRSVHandle + SPTRSVHandleType; private: @@ -199,6 +206,7 @@ class KokkosKernelsHandle GaussSeidelHandleType *gsHandle; SPGEMMHandleType *spgemmHandle; SPADDHandleType *spaddHandle; + SPTRSVHandleType *sptrsvHandle; int team_work_size; size_t shared_memory_size; @@ -214,6 +222,7 @@ class KokkosKernelsHandle bool is_owner_of_the_gs_handle; bool is_owner_of_the_spgemm_handle; bool is_owner_of_the_spadd_handle; + bool is_owner_of_the_sptrsv_handle; public: @@ -223,6 +232,7 @@ class KokkosKernelsHandle , gsHandle(NULL) , spgemmHandle(NULL) , spaddHandle(NULL) + , sptrsvHandle(NULL) , team_work_size(-1) , shared_memory_size(16128) , suggested_team_size(-1) @@ -235,6 +245,7 @@ class KokkosKernelsHandle , is_owner_of_the_gs_handle(true) , is_owner_of_the_spgemm_handle(true) , is_owner_of_the_spadd_handle(true) + , is_owner_of_the_sptrsv_handle(true) { } ~KokkosKernelsHandle(){ @@ -243,6 +254,7 @@ class KokkosKernelsHandle this->destroy_distance2_graph_coloring_handle(); this->destroy_spgemm_handle(); this->destroy_spadd_handle(); + this->destroy_sptrsv_handle(); } @@ -503,6 +515,27 @@ class KokkosKernelsHandle } + + SPTRSVHandleType *get_sptrsv_handle(){ + return this->sptrsvHandle; + } + void create_sptrsv_handle(KokkosSparse::Experimental::SPTRSVAlgorithm algm, size_type nrows, bool lower_tri) { + this->destroy_sptrsv_handle(); + this->is_owner_of_the_sptrsv_handle = true; + this->sptrsvHandle = new SPTRSVHandleType(algm, nrows, lower_tri); + this->sptrsvHandle->reset_handle_views(nrows); + this->sptrsvHandle->set_team_size(this->team_work_size); + this->sptrsvHandle->set_vector_size(this->vector_size); + } + void destroy_sptrsv_handle(){ + if (is_owner_of_the_sptrsv_handle && this->sptrsvHandle != nullptr) + { + delete this->sptrsvHandle; + this->sptrsvHandle = nullptr; + } + } + + }; // end class KokkosKernelsHandle } diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..3323bd2140 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..fa48235cca --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..d857ec4b40 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..49fdf4876b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..7510c9fc23 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..54fec5928e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..36e63aae6e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..ecb5059228 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..d0de298c77 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..92a02d43c9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..6ba6567e10 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..ebe5624f55 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..257fb54443 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..9a978a7e10 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..073f28c917 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..d2cba4e837 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..068aa39c6b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..83d36aad7e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..9f4114f6c5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..af1e586c94 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..85b6a5dec3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..4e7470982b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..c6b0fd3060 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..0152f9286e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..1a05f85daf --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..9323185852 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..78d418edd1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..3917b2ab61 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..62159c81a6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..8576eb3396 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b4f83585b6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..aff914a6d8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..cf395d7dcb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..c8870ff3cb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..0110249240 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..030ed15367 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..4e819ccb98 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..fe9d388fd2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..88eed91b46 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..9087be281f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..3bd3e8523e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..30ee17b109 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..20655b8924 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..488b36d75f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d07cbe74e6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c4cf557f1f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b895e1cdbe --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..e8524b04f4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..276a7c1f17 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..c080bdc8fe --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..37725d1a7b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..fd8068cebd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..b77517db95 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..6f91b6e1ef --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b15eda84ca --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..e5117c1efc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..08e03dbb70 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..a9fcf11d53 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c5d289f595 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..2bbb73320e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..fcb9e3e9df --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..15918d8ff7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..a026b5f377 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..f9f55efd8c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..0fbd7aec51 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..29763995cc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..df713afa3c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..11276da43d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d0f30d044c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..1bb98256ec --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..fb7cdfe027 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..73150891f6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a12bcb5e7a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ac85598d2e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..a53e6ce8af --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..9d3b52e473 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..0b98573212 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..08bf4d3732 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..687f44c59f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..358563b834 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..51473117c9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..a22d9e232e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..938d81524f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..0fe8a59da8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..58c52f4071 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..ceb5c0a3d2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..f1c18e6dcd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..f9650d590c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..e1fe22d3a1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..d3c5653cd0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c50dd71d7b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..baf7e97f59 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..9522faeeac --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..9056c2fb27 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..f7c4489e93 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..be56c10c6b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..0efd1f5fdc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7fa05f41a0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..53a4b1da88 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..b339cd103c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..12dce53f93 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..da6ee8a848 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..4657d5cc72 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..3af57ef7ed --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..e0c1c9cc66 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..274af94072 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..5baa4bd12e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..83d536b0ce --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..9ca373ddb0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..46c2c51436 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..310c536b49 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..066d67ab2f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..6e3622a0d0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..98731de2be --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c38ec7876a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..a973aecbe6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..79c309dfdd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..df78ce132a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..e5752c0539 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..7e2a226b05 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..c9ccf33087 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..940f67877b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..cf48e3b71b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..93ef266097 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..47e2d7999e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..39e89f2177 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..e4dbffad31 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..dd1eaca629 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..82b6c65be6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8a453ab13f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..73f8eced08 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..ffef31c766 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..092cac6f0c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..77aa6b1f78 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..f8feda3e64 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..45df55c389 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..99d487c44c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..f95cc05db5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..32b83a19cb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..d352031d62 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..ad63fafde7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..9fa5b4bdb4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..ef2f579af2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..bb7e13ebf5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..05e78b2229 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..e76fae03fb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..a2d87f1c1b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..4d1d87fc42 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..bcc44804d3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..4087ea82bc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b48998d402 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..61357b0311 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a124b47258 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7d2a0a89c8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..48497a10f5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..cee3141d85 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..ac1a906342 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c5922a530a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..15b5568308 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..61f6530253 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..796546ec0d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..0b753e38ad --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..378130395f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..f1112bae0b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..267738d192 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..868b747249 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..1420f8afee --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..b8a9b46b3d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..378700a5e7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8a893aabbf --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..e71a62fb00 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..a4df6fc17d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..df67138ec9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..a80249a40b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..2a3ebde1bd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..710718b138 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..848a730d32 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..be7a770960 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..e581b69239 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..5889a3ee06 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..a158ab82c5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..fa4126cb8d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..fd5cec3bec --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..615c23bf21 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..f04a2857a3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..45655b424d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..72e200771f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..731ed8f4f2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..68af30bc37 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..7530ba537f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..ffcb5da481 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..39363ebe95 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..97626164d5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..5a8d938be9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..aa4d8435a9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..201bbcb71f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..3773cb710c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..5928945b63 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..a8c83468af --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..f448c93322 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..75fffe12b6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..4d215382a9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8caab5a52d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..306e4e0f84 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..4df86a8a3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..52577e3a3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..4b55a074f2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..47674a0382 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..70516be2de --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..9b9f8a7708 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8e43e05d51 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..7bab7417de --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..eb8be29cbd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..0c9e85fbc4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..de0b33395b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..e9ba728686 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..17698a42c2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..10175fe5d1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..436d68bd5c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..fc7683e2c4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..63f991d043 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c2284d1128 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..62f268f9a1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..0dc1cea774 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..be63519546 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..779bf05ff9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..2c50d74607 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..637801675c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..f677de4a7d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..43814d466d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..0b2d32e5ad --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..1fd3f94034 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..ee42f4b790 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..b2fd11d30a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..fb2273b776 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..3b4154d3d2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..e2554afe9e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..54b3bfce79 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..65b83894ea --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..63d33d2358 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..eab6a71305 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ca6c416c84 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c636f0994c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..02390f82cb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..de3558831e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..e23b6378fd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..584c564b40 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..4bb85cd755 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..c7a659c1ae --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8d644602ad --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..3198faa04f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..47a4abd727 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d4c96cdb2d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..311215d196 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..8283440132 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..1622bca97f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_solve/KokkosSparse_sptrsv_solve_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..9c68877fbe --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8a807ac14e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8fd3491ff5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..6129427635 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..9915988b79 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..b891f62628 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..ec0261653f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..9517f99e91 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..f5a1cc5cd9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..f4bd2362b2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..d7b0da6766 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..c1e39d9aa1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..b3bef9deab --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..f97aba2ef9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..c19d0f78c8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..f5342b6c2e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..cc65c70b8e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..efc74a863d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c1301bba54 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..bf91247ae6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..3db3387379 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..afb0b57842 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..5c35a3cb47 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..a978bd1085 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..47933ce1cf --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..7376f81a37 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8b88aaf1eb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..8669b23824 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..761cefeb5f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..e5b6f4d22b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..7bace6d24a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..5791e37f22 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..8e3ee7d441 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..0400dfba3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..2845c6f66f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..78a9607b18 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..82642362f7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..44a1f96b6d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..e5258dc34d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..000acf7a16 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..d763074ddd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..0210557ada --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..17a5cdeb7b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..3c4b17e372 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..18a090e627 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..be89342077 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..2e2203ae1e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..a1671f065c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..83ddcb5b02 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..c4b7927c7d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..302d5dee89 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..58bf26083d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..a6759a173f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..7424904017 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..f7d1ae779d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..4f91ef5a3b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..adaacd2130 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..f70bd73474 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c629d3b292 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..f91a71ccd1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..670d89aacf --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..5d9486e67a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..548e1dd010 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..5adcd49b06 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_double__size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..7e058b3562 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..d4a422e2da --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..400f754e83 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..a08ed7503d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..7ec5c5c8b5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..5423d6cc94 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..a316415a6a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..c2495fe290 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..fbab3a6e06 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..86f171c4ad --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..e6ddc9bbf4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..2be4e3b0b9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..e2e58e68d5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..89a5dac0de --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..7af86b472c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..c19d614c3e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..ef4d0ade28 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..46ac76df7b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..585ecc5671 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..f4e9d178dd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..f1909643c9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..4747a2d4e9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..a48192991c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..a06de7946f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a5b1e916a7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..61fc6a31ef --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..81bd12051c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..6fee98d094 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..1161187504 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..3673689dbd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..a8f81c024c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..7504f327a5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..cfd1834af4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..a59672a70b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..3996cfc8ec --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..b8f04edd7f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..223493566e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..56ace08a9a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b43f975515 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..1a6cd660ef --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..268f3f0709 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..29269ce0fc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..975e1fa5e7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..bb0055b966 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..b0e19587d2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..650411f9e8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..ae1bc42714 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..6c83bb9570 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..446ab35c82 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..00f8e047e1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c5a5141b3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..e37057a429 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..f7129fee2f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..083ca39b83 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..ffa0d604ff --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..e016420b22 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..1b59463cee --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..b98cc5a9b2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..0689a994bb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..69f72c43ce --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..c06d97fd89 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..8da966fed8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..9b410462e9 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..2e58f3b61a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_Kokkos_complex_float__size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..92eb03009f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..fe1415742d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..4d081c94cd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..a79b849a29 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..84ff911c3e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..7504761dcd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..cddd88b9f4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..13d4be6965 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..4358227d3a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..8a48d468c3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..560bb4eb9d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..861b9fe963 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..50b2637873 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..10c2e398be --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..16f7a73863 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..90ff5c26f2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..d0abd6194c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..2a2c6a657f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..2c635e4e79 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..fe19b11bd6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..bfa69cdb12 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..5fcfb4dc82 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..d634093744 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..26d4d9b98b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..3387743b90 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ed1a265bed --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..cedf857f27 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..b3891da502 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..94096cb6c4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..4e95f2ae6c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..e49fbed07a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..5a7f50dd5e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..afd7da0975 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..e84ab52075 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..f880b6d1dc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..1f9d3861bc --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..fee815eeed --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..eb8427be7c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..74437c0343 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..5bea04caa1 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..1292a89404 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..58c6610f6d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..11e7c94c0d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..ee37bbd626 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..29a8ac9b12 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..d2e7eccbe3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..be3bc310f4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..eaa9111d5c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..1c7e94a27c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..67801217cb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..dd4eba4c41 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..1b4315b89b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..796c9fcb04 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..a669a675eb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..d9b7e85f85 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..2b5c93f725 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..3f973f9356 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..a719874461 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..c4eb677606 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..62d508026d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..6f266747d4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..810acf1a4e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..19801208c6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..e1a89f4421 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_double_size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..dafdb1982e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..1b2c5a408d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..1bbe492164 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..315e9e5586 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..aa467c4c25 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..57a4e3ccdf --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..5816982b8c --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..ccdd448c44 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..2dbea43165 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..108d5c172f --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..263e2a695d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..7efb1c08c8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..7b0307aaa8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..c2218292ea --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..f3c044ed75 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..de77a37b80 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..14323c8c3b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..9c2832e61e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..f9c4226ee3 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..b12ede9022 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..d4a23851c2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..6bd5f4b008 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..d682ce23a0 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..2d219991c8 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..a8db9e7171 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..ff09cd0249 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..ffebf8ec13 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..e73059835a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..98177fe704 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..a23c2f13b4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..cbb77b52f6 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..998f38629d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_int_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..3ba1c61e51 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..d7ea0a0bdb --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..8ae27d6f96 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..6082fbc6ad --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..2375f3ae99 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..217f5748b4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..b8dbac223a --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..fd51c3802b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..675337e032 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..02c6b2d7b2 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..69fd53458b --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..1cf034087d --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..a9688ed076 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..22bfbceaa5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..4aa61a4769 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..eca1233508 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int64_t_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..fb6c2d94a4 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..406c0d9662 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..9c4b905c8e --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..9ed0eb6f37 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..7106618e40 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp new file mode 100644 index 0000000000..76c9260295 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..7e13805286 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp new file mode 100644 index 0000000000..f4b5ba03fd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutLeft_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp new file mode 100644 index 0000000000..4733f52873 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp new file mode 100644 index 0000000000..24dbb692d7 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Cuda_CudaUVMSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp new file mode 100644 index 0000000000..198437b5cd --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp new file mode 100644 index 0000000000..b5b5ad3376 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_OpenMP_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp new file mode 100644 index 0000000000..12db260f59 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp new file mode 100644 index 0000000000..455ead14d5 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Serial_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp new file mode 100644 index 0000000000..2c7f68e334 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HBWSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp new file mode 100644 index 0000000000..a137b0af13 --- /dev/null +++ b/src/impl/generated_specializations_cpp/sptrsv_symbolic/KokkosSparse_sptrsv_symbolic_eti_spec_inst_float_size_t_int_LayoutRight_Threads_HostSpace.cpp @@ -0,0 +1,60 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#define KOKKOSKERNELS_IMPL_COMPILE_LIBRARY true +#include "KokkosKernels_config.h" +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" + +namespace KokkosSparse { +namespace Impl { + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +} // Impl +} // KokkosSparse +#endif diff --git a/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_avail.hpp b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_avail.hpp new file mode 100644 index 0000000000..48cbba9c9e --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_avail.hpp @@ -0,0 +1,2354 @@ +#ifndef KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL_HPP_ +#define KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosSparse { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosSparse +#endif // KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL_HPP_ diff --git a/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_decl.hpp b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_decl.hpp new file mode 100644 index 0000000000..a48409d971 --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_solve_eti_spec_decl.hpp @@ -0,0 +1,2354 @@ +#ifndef KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL_HPP_ +#define KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosSparse { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosSparse +#endif // KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL_HPP_ diff --git a/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_avail.hpp b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_avail.hpp new file mode 100644 index 0000000000..106ab29163 --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_avail.hpp @@ -0,0 +1,2354 @@ +#ifndef KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL_HPP_ +#define KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosSparse { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosSparse +#endif // KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL_HPP_ diff --git a/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_decl.hpp b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_decl.hpp new file mode 100644 index 0000000000..85d28adb64 --- /dev/null +++ b/src/impl/generated_specializations_hpp/KokkosSparse_sptrsv_symbolic_eti_spec_decl.hpp @@ -0,0 +1,2354 @@ +#ifndef KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL_HPP_ +#define KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL_HPP_ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +namespace KokkosSparse { +namespace Impl { + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(double, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(float, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTLEFT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutLeft, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDASPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_CUDA) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_CUDAUVMSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Cuda, Kokkos::CudaUVMSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HOSTSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::HostSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_OPENMP) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::OpenMP, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_THREADS) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Threads, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, int, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif + +#if defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_LAYOUTRIGHT) \ + && defined (KOKKOSKERNELS_INST_EXECSPACE_SERIAL) \ + && defined (KOKKOSKERNELS_INST_MEMSPACE_HBWSPACE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) + KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL(Kokkos::complex, int64_t, size_t, Kokkos::LayoutRight, Kokkos::Serial, Kokkos::Experimental::HBWSpace) +#endif +} // Impl +} // KokkosSparse +#endif // KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL_HPP_ diff --git a/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_avail.hpp b/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_avail.hpp new file mode 100644 index 0000000000..4d22b0ca0d --- /dev/null +++ b/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_avail.hpp @@ -0,0 +1,64 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSPARSE_SPTRSV_SOLVE_TPL_SPEC_AVAIL_HPP_ +#define KOKKOSPARSE_SPTRSV_SOLVE_TPL_SPEC_AVAIL_HPP_ + +namespace KokkosSparse { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct sptrsv_solve_tpl_spec_avail { + enum : bool { value = false }; +}; + + +} +} + +#endif diff --git a/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_decl.hpp b/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_decl.hpp new file mode 100644 index 0000000000..f0fe445a24 --- /dev/null +++ b/src/impl/tpls/KokkosSparse_sptrsv_solve_tpl_spec_decl.hpp @@ -0,0 +1,52 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSPARSE_SPTRSV_SOLVE_TPL_SPEC_DECL_HPP_ +#define KOKKOSPARSE_SPTRSV_SOLVE_TPL_SPEC_DECL_HPP_ + +namespace KokkosSparse { +namespace Impl { +} +} + +#endif diff --git a/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_avail.hpp b/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_avail.hpp new file mode 100644 index 0000000000..5f43203b9c --- /dev/null +++ b/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_avail.hpp @@ -0,0 +1,61 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSPARSE_SPTRSV_SYMBOLIC_TPL_SPEC_AVAIL_HPP_ +#define KOKKOSPARSE_SPTRSV_SYMBOLIC_TPL_SPEC_AVAIL_HPP_ + +namespace KokkosSparse { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct sptrsv_symbolic_tpl_spec_avail { + enum : bool { value = false }; +}; + + +} +} + +#endif diff --git a/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_decl.hpp b/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_decl.hpp new file mode 100644 index 0000000000..a4d134f0fa --- /dev/null +++ b/src/impl/tpls/KokkosSparse_sptrsv_symbolic_tpl_spec_decl.hpp @@ -0,0 +1,52 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSPARSE_SPTRSV_SYMBOLIC_TPL_SPEC_DECL_HPP_ +#define KOKKOSPARSE_SPTRSV_SYMBOLIC_TPL_SPEC_DECL_HPP_ + +namespace KokkosSparse { +namespace Impl { +} +} + +#endif diff --git a/src/sparse/KokkosSparse_sptrsv.hpp b/src/sparse/KokkosSparse_sptrsv.hpp new file mode 100644 index 0000000000..6677e779b5 --- /dev/null +++ b/src/sparse/KokkosSparse_sptrsv.hpp @@ -0,0 +1,223 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +/// \file KokkosSparse_sptrsv.hpp +/// \brief Parallel sparse triangular solve +/// +/// This file provides KokkosSparse::sptrsv. This function performs a +/// local (no MPI) sparse triangular solve on matrices stored in +/// compressed row sparse ("Crs") format. + +#ifndef KOKKOSSPARSE_SPTRSV_HPP_ +#define KOKKOSSPARSE_SPTRSV_HPP_ + +#include + +//#include "KokkosSparse_sptrsv_handle.hpp" +#include "KokkosKernels_helpers.hpp" +#include "KokkosSparse_sptrsv_symbolic_spec.hpp" +#include "KokkosSparse_sptrsv_solve_spec.hpp" + +namespace KokkosSparse { +namespace Experimental { + +#define SAME_TYPE(A, B) std::is_same::type, typename std::remove_const::type>::value + + template + void sptrsv_symbolic( + KernelHandle *handle, + lno_row_view_t_ rowmap, + lno_nnz_view_t_ entries) + { + typedef typename KernelHandle::size_type size_type; + typedef typename KernelHandle::nnz_lno_t ordinal_type; + + static_assert(SAME_TYPE(typename lno_row_view_t_::non_const_value_type, size_type), + "sptrsv_symbolic: A size_type must match KernelHandle size_type (const doesn't matter)"); + + static_assert(SAME_TYPE(typename lno_nnz_view_t_::non_const_value_type, ordinal_type), + "sptrsv_symbolic: A entry type must match KernelHandle entry type (aka nnz_lno_t, and const doesn't matter)"); + + + typedef typename KernelHandle::const_size_type c_size_t; + typedef typename KernelHandle::const_nnz_lno_t c_lno_t; + typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; + + typedef typename KernelHandle::HandleExecSpace c_exec_t; + typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; + typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; + + typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; + const_handle_type tmp_handle (*handle); + + typedef Kokkos::View< + typename lno_row_view_t_::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename lno_row_view_t_::device_type, + Kokkos::MemoryTraits > RowMap_Internal; + + typedef Kokkos::View< + typename lno_nnz_view_t_::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename lno_nnz_view_t_::device_type, + Kokkos::MemoryTraits > Entries_Internal; + + + RowMap_Internal rowmap_i = rowmap; + Entries_Internal entries_i = entries; + + KokkosSparse::Impl::SPTRSV_SYMBOLIC::sptrsv_symbolic (&tmp_handle, rowmap_i, entries_i); + + } // sptrsv_symbolic + + + + template + void sptrsv_solve( + KernelHandle *handle, + lno_row_view_t_ rowmap, + lno_nnz_view_t_ entries, + scalar_nnz_view_t_ values, + BType b, + XType x) + { + typedef typename KernelHandle::size_type size_type; + typedef typename KernelHandle::nnz_lno_t ordinal_type; + typedef typename KernelHandle::nnz_scalar_t scalar_type; + + static_assert(SAME_TYPE(typename lno_row_view_t_::non_const_value_type, size_type), + "sptrsv_solve: A size_type must match KernelHandle size_type (const doesn't matter)"); + static_assert(SAME_TYPE(typename lno_nnz_view_t_::non_const_value_type, ordinal_type), + "sptrsv_solve: A entry type must match KernelHandle entry type (aka nnz_lno_t, and const doesn't matter)"); + static_assert(SAME_TYPE(typename scalar_nnz_view_t_::value_type, scalar_type), + "sptrsv_solve: A scalar type must match KernelHandle entry type (aka nnz_lno_t, and const doesn't matter)"); + + static_assert (Kokkos::Impl::is_view::value, + "sptrsv: b is not a Kokkos::View."); + static_assert (Kokkos::Impl::is_view::value, + "sptrsv: x is not a Kokkos::View."); + static_assert ((int) BType::rank == (int) XType::rank, + "sptrsv: The ranks of b and x do not match."); + static_assert (BType::rank == 1, + "sptrsv: b and x must both either have rank 1."); + static_assert (std::is_same::value, + "sptrsv: The output x must be nonconst."); + static_assert (std::is_same::value, + "sptrsv: Views BType and XType have different device_types."); + static_assert (std::is_same::value, + "sptrsv: KernelHandle and Views have different execution spaces."); + static_assert (std::is_same::value, + "sptrsv: rowmap and entries have different device types."); + static_assert (std::is_same::value, + "sptrsv: rowmap and values have different device types."); + + + typedef typename KernelHandle::const_size_type c_size_t; + typedef typename KernelHandle::const_nnz_lno_t c_lno_t; + typedef typename KernelHandle::const_nnz_scalar_t c_scalar_t; + + typedef typename KernelHandle::HandleExecSpace c_exec_t; + typedef typename KernelHandle::HandleTempMemorySpace c_temp_t; + typedef typename KernelHandle::HandlePersistentMemorySpace c_persist_t; + + typedef typename KokkosKernels::Experimental::KokkosKernelsHandle const_handle_type; + const_handle_type tmp_handle (*handle); + + typedef Kokkos::View< + typename lno_row_view_t_::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename lno_row_view_t_::device_type, + Kokkos::MemoryTraits > RowMap_Internal; + + typedef Kokkos::View< + typename lno_nnz_view_t_::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename lno_nnz_view_t_::device_type, + Kokkos::MemoryTraits > Entries_Internal; + + typedef Kokkos::View< + typename scalar_nnz_view_t_::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename scalar_nnz_view_t_::device_type, + Kokkos::MemoryTraits > Values_Internal; + + + typedef Kokkos::View< + typename BType::const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename BType::device_type, + Kokkos::MemoryTraits > BType_Internal; + + typedef Kokkos::View< + typename XType::non_const_value_type*, + typename KokkosKernels::Impl::GetUnifiedLayout::array_layout, + typename XType::device_type, + Kokkos::MemoryTraits > XType_Internal; + + + RowMap_Internal rowmap_i = rowmap; + Entries_Internal entries_i = entries; + Values_Internal values_i = values; + + BType_Internal b_i = b; + XType_Internal x_i = x; + + KokkosSparse::Impl::SPTRSV_SOLVE::sptrsv_solve (&tmp_handle, rowmap_i, entries_i, values_i, b_i, x_i); + + } // sptrsv_solve + +} // namespace Experimental +} // namespace KokkosSparse + +#undef SAME_TYPE + +#endif // KOKKOSSPARSE_SPTRSV_HPP_ + diff --git a/src/sparse/KokkosSparse_sptrsv_handle.hpp b/src/sparse/KokkosSparse_sptrsv_handle.hpp new file mode 100644 index 0000000000..c378149219 --- /dev/null +++ b/src/sparse/KokkosSparse_sptrsv_handle.hpp @@ -0,0 +1,261 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#include +#include +#include +#include + +#ifndef _SPTRSVHANDLE_HPP +#define _SPTRSVHANDLE_HPP + +namespace KokkosSparse { +namespace Experimental { + +enum class SPTRSVAlgorithm { SEQLVLSCHD_RP, SEQLVLSCHD_TP1, SEQLVLSCHED_TP2 }; + +template +class SPTRSVHandle { +public: + + typedef ExecutionSpace HandleExecSpace; + typedef TemporaryMemorySpace HandleTempMemorySpace; + typedef PersistentMemorySpace HandlePersistentMemorySpace; + + typedef ExecutionSpace execution_space; + typedef HandlePersistentMemorySpace memory_space; + + + typedef typename std::remove_const::type size_type; + typedef const size_type const_size_type; + + typedef typename std::remove_const::type nnz_lno_t; + typedef const nnz_lno_t const_nnz_lno_t; + + typedef typename std::remove_const::type nnz_scalar_t; + typedef const nnz_scalar_t const_nnz_scalar_t; + + + typedef typename Kokkos::View nnz_row_view_temp_t; + typedef typename Kokkos::View nnz_row_view_t; + // typedef typename row_lno_persistent_work_view_t::HostMirror row_lno_persistent_work_host_view_t; //Host view type + + typedef typename Kokkos::View nnz_scalar_view_temp_t; + typedef typename Kokkos::View nnz_scalar_view_t; + + + typedef typename Kokkos::View nnz_lno_view_temp_t; + typedef typename Kokkos::View nnz_lno_view_t; + // typedef typename nnz_lno_persistent_work_view_t::HostMirror nnz_lno_persistent_work_host_view_t; //Host view type + + + typedef typename std::make_signed::type signed_integral_t; + typedef Kokkos::View< signed_integral_t*, typename nnz_row_view_t::array_layout, typename nnz_row_view_t::device_type, typename nnz_row_view_t::memory_traits > signed_nnz_lno_view_t; + + +private: + + signed_nnz_lno_view_t level_list; + nnz_lno_view_t nodes_per_level; + nnz_lno_view_t nodes_grouped_by_level; + + size_type nrows; + size_type nlevel; + + bool lower_tri; + + bool symbolic_complete; + + SPTRSVAlgorithm algm; + + int team_size; + int vector_size; + +public: + + SPTRSVHandle ( SPTRSVAlgorithm choice, const size_type nrows_, bool lower_tri_, bool symbolic_complete_ = false ) : + level_list(), + nodes_per_level(), + nodes_grouped_by_level(), + nrows(nrows_), + nlevel(0), + lower_tri( lower_tri_ ), + symbolic_complete( symbolic_complete_ ), + algm(choice), + team_size(-1), + vector_size(-1) + {} + +#if 0 + SPTRSVHandle ( SPTRSVAlgorithm choice, const size_type nrows_, bool lower_tri_, bool symbolic_complete_ = false ) : + level_list( Kokkos::ViewAllocateWithoutInitializing("level_list"), nrows), + nodes_per_level("nodes_per_level", nrows), + nodes_grouped_by_level("nodes_grouped_by_level", nrows), + nrows(nrows_), + nlevel(0), + lower_tri( lower_tri_ ), + symbolic_complete( symbolic_complete_ ), + algm(choice) + { + // WithoutInitializing + Kokkos::deep_copy( level_list, signed_integral_t(-1) ); + } + +/* + template + SPTRSVHandle ( SPTRSVHandle< rhslno_row_view_t_, rhslno_nnz_view_t_, rhsscalar_nnz_view_t_, rhsExecutionSpace, rhsMemorySpace > & rhs ) { + + this->level_list = rhs.level_list; + this->nodes_per_level = rhs.nodes_per_level; + this->nodes_grouped_by_level = rhs.nodes_grouped_by_level; + this->nrows = rhs.nrows; + this->nlevel = rhs.nlevel; + this->lower_tri = rhs.lower_tri; + this->symbolic_complete = rhs.symbolic_complete; + this->algm = rhs.algm; + } + + template + SPTRSVHandle & operator= ( SPTRSVHandle< rhslno_row_view_t_, rhslno_nnz_view_t_, rhsscalar_nnz_view_t_, rhsExecutionSpace, rhsMemorySpace > & rhs ) { + + this->level_list = rhs.level_list; + this->nodes_per_level = rhs.nodes_per_level; + this->nodes_grouped_by_level = rhs.nodes_grouped_by_level; + this->nrows = rhs.nrows; + this->nlevel = rhs.nlevel; + this->lower_tri = rhs.lower_tri; + this->symbolic_complete = rhs.symbolic_complete; + this->algm = rhs.algm; + return *this; + } +*/ + +#endif + + void reset_handle_views( const size_type nrows_ ) { + set_nrows(nrows_); + set_num_levels(0); + level_list = signed_nnz_lno_view_t( Kokkos::ViewAllocateWithoutInitializing("level_list"), nrows_), + Kokkos::deep_copy( level_list, signed_integral_t(-1) ); + nodes_per_level = nnz_lno_view_t("nodes_per_level", nrows_), + nodes_grouped_by_level = nnz_lno_view_t("nodes_grouped_by_level", nrows_), + reset_symbolic_complete(); + } + + virtual ~SPTRSVHandle() {}; + + + void set_algorithm(SPTRSVAlgorithm choice) { algm = choice; } + + SPTRSVAlgorithm get_algorithm() { return algm; } + + KOKKOS_INLINE_FUNCTION + signed_nnz_lno_view_t get_level_list() const { return level_list; } + + KOKKOS_INLINE_FUNCTION + nnz_lno_view_t get_nodes_per_level() const { return nodes_per_level; } + + KOKKOS_INLINE_FUNCTION + nnz_lno_view_t get_nodes_grouped_by_level() const { return nodes_grouped_by_level; } + + KOKKOS_INLINE_FUNCTION + size_type get_nrows() const { return nrows; } + + KOKKOS_INLINE_FUNCTION + void set_nrows(const size_type nrows_) { this->nrows = nrows_; } + + bool is_lower_tri() const { return lower_tri; } + bool is_upper_tri() const { return !lower_tri; } + + bool is_symbolic_complete() const { return symbolic_complete; } + + size_type get_num_levels() const { return nlevel; } + void set_num_levels(size_type nlevels_) { this->nlevel = nlevels_; } + + void set_symbolic_complete() { this->symbolic_complete = true; } + void reset_symbolic_complete() { this->symbolic_complete = false; } + + void set_team_size(const int ts) {this->team_size = ts;} + int get_team_size() const {return this->team_size;} + + void set_vector_size(const int vs) {this->vector_size = vs;} + int get_vector_size() const {return this->vector_size;} + + void print_algorithm() { + if ( algm == SPTRSVAlgorithm::SEQLVLSCHD_RP ) + std::cout << "SEQLVLSCHD_RP" << std::endl;; + + if ( algm == SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) + std::cout << "SEQLVLSCHD_TP1" << std::endl;; + + if ( algm == SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) + std::cout << "SEQLVLSCHED_TP2" << std::endl;; + std::cout << "WARNING: With CUDA this is currently only reliable with int-int ordinal-offset pair" << std::endl; + } + + inline SPTRSVAlgorithm StringToSPTRSVAlgorithm(std::string & name) { + if(name=="SPTRSV_DEFAULT") return SPTRSVAlgorithm::SEQLVLSCHD_RP; + else if(name=="SPTRSV_RANGEPOLICY") return SPTRSVAlgorithm::SEQLVLSCHD_RP; + else if(name=="SPTRSV_TEAMPOLICY1") return SPTRSVAlgorithm::SEQLVLSCHD_TP1; + else if(name=="SPTRSV_TEAMPOLICY2") return SPTRSVAlgorithm::SEQLVLSCHED_TP2; + else + throw std::runtime_error("Invalid SPTRSVAlgorithm name"); + } + +}; + +} // namespace Experimental +} // namespace Kokkos + +#endif diff --git a/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp b/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp new file mode 100644 index 0000000000..fad0050870 --- /dev/null +++ b/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp @@ -0,0 +1,684 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSSPARSE_IMPL_SPTRSV_SOLVE_HPP_ +#define KOKKOSSPARSE_IMPL_SPTRSV_SOLVE_HPP_ + +/// \file KokkosSparse_impl_sptrsv.hpp +/// \brief Implementation(s) of sparse triangular solve. + +#include +#include +#include + +//#define LVL_OUTPUT_INFO + +namespace KokkosSparse { +namespace Impl { +namespace Experimental { + + +struct UnsortedTag {}; + + +template +struct LowerTriLvlSchedRPSolverFunctor +{ + typedef typename EntriesType::non_const_value_type lno_t; + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + LowerTriLvlSchedRPSolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, NGBLType nodes_grouped_by_level_ ) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()(const lno_t i) const { + auto rowid = nodes_grouped_by_level(i); + // Assuming indices are sorted per row, diag entry is final index in the list + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + + for ( auto ptr = soffset; ptr < eoffset; ++ptr ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + rhs_rowid = rhs_rowid - val*lhs(colid); + } + else { + lhs(rowid) = rhs_rowid/val; + } + } // end for ptr + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const lno_t i) const { + auto rowid = nodes_grouped_by_level(i); + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + auto diag = -1; + + for ( auto ptr = soffset; ptr < eoffset; ++ptr ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + rhs_rowid = rhs_rowid - val*lhs(colid); + } + else { + diag = ptr; + } + } // end for ptr + lhs(rowid) = rhs_rowid/values(diag); + } +}; + + +template +struct LowerTriLvlSchedTP1SolverFunctor +{ + typedef typename RowMapType::execution_space execution_space; + typedef Kokkos::TeamPolicy policy_type; + typedef typename policy_type::member_type member_type; + typedef typename EntriesType::non_const_value_type lno_t; + typedef typename ValuesType::non_const_value_type scalar_t; + + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + long node_count; + long node_groups; + + + LowerTriLvlSchedTP1SolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, const NGBLType &nodes_grouped_by_level_, long node_count_, long node_groups_ = 0) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_), node_count(node_count_), node_groups(node_groups_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()( const member_type & team ) const { + auto my_league = team.league_rank(); // map to rowid + auto rowid = nodes_grouped_by_level(my_league + node_count); + auto my_team = team.team_rank(); + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + }, diff ); + + team.team_barrier(); + + // At end, finalize rowid == colid + // only one thread should do this; can also use Kokkos::single + if ( my_team == 0 ) + { + // ASSUMPTION: sorted diagonal value located at eoffset - 1 + lhs(rowid) = (rhs_rowid+diff)/values(eoffset-1); + } + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const member_type & team) const { + auto my_league = team.league_rank(); // map to rowid + auto rowid = nodes_grouped_by_level(my_league + node_count); + auto my_team = team.team_rank(); + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + auto diag = -1; + + Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + else { + diag = ptr; + } + }, diff ); + + team.team_barrier(); + + // At end, finalize rowid == colid + // only one thread should do this; can also use Kokkos::single + if ( my_team == 0 ) + { + // ASSUMPTION: sorted diagonal value located at eoffset - 1 + lhs(rowid) = (rhs_rowid+diff)/values(diag); + } + } +}; + +// FIXME CUDA: This algorithm not working with all integral type combos +// In any case, this serves as a skeleton for 3-level hierarchical parallelism for alg dev +template +struct LowerTriLvlSchedTP2SolverFunctor +{ + typedef typename RowMapType::execution_space execution_space; + typedef Kokkos::TeamPolicy policy_type; + typedef typename policy_type::member_type member_type; + typedef typename EntriesType::non_const_value_type lno_t; + typedef typename ValuesType::non_const_value_type scalar_t; + + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + long node_count; + long node_groups; + + + LowerTriLvlSchedTP2SolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, const NGBLType &nodes_grouped_by_level_, long node_count_, long node_groups_ = 0) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_), node_count(node_count_), node_groups(node_groups_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()(const member_type & team) const { + auto my_league = team.league_rank(); // map to rowid + + size_t nrows = row_map.extent(0) - 1; + + Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, node_groups ), [&] ( const long ng ) { + auto rowid = nodes_grouped_by_level(node_count + my_league*node_groups + ng); + if ( size_t(rowid) < nrows ) { + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + }, diff ); + + // ASSUMPTION: sorted diagonal value located at eoffset - 1 + lhs(rowid) = (rhs_rowid+diff)/values(eoffset-1); + } // end if + }); // end TeamThreadRange + + team.team_barrier(); + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const member_type & team) const { + auto my_league = team.league_rank(); // map to rowid + + size_t nrows = row_map.extent(0) - 1; + + Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, node_groups ), [&] ( const long ng ) { + auto rowid = nodes_grouped_by_level(node_count + my_league*node_groups + ng); + if ( size_t(rowid) < nrows ) { + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + auto diag = -1; + Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + else { + diag = ptr; + } + }, diff ); + + // ASSUMPTION: sorted diagonal value located at eoffset - 1 + lhs(rowid) = (rhs_rowid+diff)/values(diag); + } // end if + }); // end TeamThreadRange + + team.team_barrier(); + } +}; + +template +struct UpperTriLvlSchedRPSolverFunctor +{ + typedef typename EntriesType::non_const_value_type lno_t; + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + + UpperTriLvlSchedRPSolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, const NGBLType &nodes_grouped_by_level_ ) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()(const lno_t i) const { + auto rowid = nodes_grouped_by_level(i); + // Assuming indices are sorted per row, diag entry is final index in the list + long soffset = row_map(rowid); + long eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + for ( long ptr = eoffset-1; ptr >= soffset; --ptr ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + rhs_rowid = rhs_rowid - val*lhs(colid); + } + else { + lhs(rowid) = rhs_rowid/val; + } + } // end for ptr + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const lno_t i) const { + auto rowid = nodes_grouped_by_level(i); + long soffset = row_map(rowid); + long eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + auto diag = -1; + for ( long ptr = eoffset-1; ptr >= soffset; --ptr ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + rhs_rowid = rhs_rowid - val*lhs(colid); + } + else { + diag = ptr; + } + } // end for ptr + lhs(rowid) = rhs_rowid/values(diag); + } + +}; + +template +struct UpperTriLvlSchedTP1SolverFunctor +{ + typedef typename RowMapType::execution_space execution_space; + typedef Kokkos::TeamPolicy policy_type; + typedef typename policy_type::member_type member_type; + typedef typename EntriesType::non_const_value_type lno_t; + typedef typename ValuesType::non_const_value_type scalar_t; + + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + long node_count; + long node_groups; + + + UpperTriLvlSchedTP1SolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, const NGBLType &nodes_grouped_by_level_, long node_count_, long node_groups_ = 0 ) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_), node_count(node_count_), node_groups(node_groups_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()(const member_type & team) const { + auto my_league = team.league_rank(); // map to rowid + auto rowid = nodes_grouped_by_level(my_league + node_count); + auto my_team = team.team_rank(); + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + }, diff ); + + team.team_barrier(); + + // At end, finalize rowid == colid + // only one thread should do this, also can use Kokkos::single + if ( my_team == 0 ) + { + // ASSUMPTION: sorted diagonal value located at start offset + lhs(rowid) = (rhs_rowid+diff)/values(soffset); + } + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const member_type & team) const { + auto my_league = team.league_rank(); // map to rowid + auto rowid = nodes_grouped_by_level(my_league + node_count); + auto my_team = team.team_rank(); + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + auto diag = -1; + + Kokkos::parallel_reduce( Kokkos::TeamThreadRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + else { + diag = ptr; + } + }, diff ); + team.team_barrier(); + + // At end, finalize rowid == colid + // only one thread should do this, also can use Kokkos::single + if ( my_team == 0 ) + { + // ASSUMPTION: sorted diagonal value located at start offset + lhs(rowid) = (rhs_rowid+diff)/values(diag); + } + } + +}; + + +// FIXME CUDA: This algorithm not working with all integral type combos +// In any case, this serves as a skeleton for 3-level hierarchical parallelism for alg dev +template +struct UpperTriLvlSchedTP2SolverFunctor +{ + typedef typename RowMapType::execution_space execution_space; + typedef Kokkos::TeamPolicy policy_type; + typedef typename policy_type::member_type member_type; + typedef typename EntriesType::non_const_value_type lno_t; + typedef typename ValuesType::non_const_value_type scalar_t; + + RowMapType row_map; + EntriesType entries; + ValuesType values; + LHSType lhs; + RHSType rhs; + NGBLType nodes_grouped_by_level; + + long node_count; + long node_groups; + + + UpperTriLvlSchedTP2SolverFunctor( const RowMapType &row_map_, const EntriesType &entries_, const ValuesType &values_, LHSType &lhs_, const RHSType &rhs_, const NGBLType &nodes_grouped_by_level_, long node_count_, long node_groups_ = 0 ) : + row_map(row_map_), entries(entries_), values(values_), lhs(lhs_), rhs(rhs_), nodes_grouped_by_level(nodes_grouped_by_level_), node_count(node_count_), node_groups(node_groups_) {} + + + KOKKOS_INLINE_FUNCTION + void operator()( const member_type & team ) const { + auto my_league = team.league_rank(); // map to rowid + + size_t nrows = row_map.extent(0) - 1; + + Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, node_groups ), [&] ( const long ng ) { + auto rowid = nodes_grouped_by_level(node_count + my_league*node_groups + ng); + if ( size_t(rowid) < nrows ) { + + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + }, diff ); + + // ASSUMPTION: sorted diagonal value located at start offset + lhs(rowid) = (rhs_rowid+diff)/values(soffset); + } // end if + }); // end TeamThreadRange + + team.team_barrier(); + } + + KOKKOS_INLINE_FUNCTION + void operator()(const UnsortedTag&, const member_type & team ) const { + auto my_league = team.league_rank(); // map to rowid + + size_t nrows = row_map.extent(0) - 1; + + Kokkos::parallel_for( Kokkos::TeamThreadRange( team, 0, node_groups ), [&] ( const long ng ) { + auto rowid = nodes_grouped_by_level(node_count + my_league*node_groups + ng); + if ( size_t(rowid) < nrows ) { + auto soffset = row_map(rowid); + auto eoffset = row_map(rowid+1); + auto rhs_rowid = rhs(rowid); + scalar_t diff = scalar_t(0.0); + + auto diag = -1; + Kokkos::parallel_reduce( Kokkos::ThreadVectorRange( team, soffset, eoffset ), [&] ( const long ptr, scalar_t &tdiff ) { + auto colid = entries(ptr); + auto val = values(ptr); + if ( colid != rowid ) { + tdiff = tdiff - val*lhs(colid); + } + else { + diag = ptr; + } + }, diff ); + + // ASSUMPTION: sorted diagonal value located at start offset + lhs(rowid) = (rhs_rowid+diff)/values(diag); + } // end if + }); // end TeamThreadRange + + team.team_barrier(); + } + +}; + + +template < class TriSolveHandle, class RowMapType, class EntriesType, class ValuesType, class RHSType, class LHSType > +void lower_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const EntriesType entries, const ValuesType values, const RHSType & rhs, LHSType &lhs) { + + typedef typename TriSolveHandle::execution_space execution_space; + typedef typename TriSolveHandle::size_type size_type; + typedef typename TriSolveHandle::nnz_lno_view_t NGBLType; + + auto nlevels = thandle.get_num_levels(); + // Keep this a host View, create device version and copy to back to host during scheduling + auto nodes_per_level = thandle.get_nodes_per_level(); + auto hnodes_per_level = Kokkos::create_mirror_view(nodes_per_level); + Kokkos::deep_copy(hnodes_per_level, nodes_per_level); + + auto nodes_grouped_by_level = thandle.get_nodes_grouped_by_level(); + + size_type node_count = 0; + + // This must stay serial; would be nice to try out Cuda's graph stuff to reduce kernel launch overhead + for ( size_type lvl = 0; lvl < nlevels; ++lvl ) { + size_type lvl_nodes = hnodes_per_level(lvl); + + if ( lvl_nodes != 0 ) { + + if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP ) { + Kokkos::parallel_for( "parfor_fixed_lvl", Kokkos::RangePolicy( node_count, node_count+lvl_nodes ), LowerTriLvlSchedRPSolverFunctor (row_map, entries, values, lhs, rhs, nodes_grouped_by_level) ); + } + else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) { + typedef Kokkos::TeamPolicy policy_type; + int team_size = thandle.get_team_size(); + if ( team_size == -1 ) { + team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 256; + } + + LowerTriLvlSchedTP1SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); + Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); + } + else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) { + typedef Kokkos::TeamPolicy tvt_policy_type; + + int team_size = thandle.get_team_size(); + if ( team_size == -1 ) { + team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 128; + } + int vector_size = thandle.get_team_size(); + if ( vector_size == -1 ) { + vector_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 4; + } + + // This impl: "chunk" lvl_nodes into node_groups; a league_rank is responsible for processing that many nodes + // TeamThreadRange over number of node_groups + // To avoid masking threads, 1 thread (team) per node in node_group + // ThreadVectorRange responsible for the actual solve computation + const int node_groups = team_size; + + LowerTriLvlSchedTP2SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count, node_groups); + Kokkos::parallel_for("parfor_u_team_vector", tvt_policy_type( (int)std::ceil((float)lvl_nodes/(float)node_groups) , team_size, vector_size ), tstf); + } // end elseif + + node_count += lvl_nodes; + + } // end if + } // end for lvl + +} // end lower_tri_solve + + +template < class TriSolveHandle, class RowMapType, class EntriesType, class ValuesType, class RHSType, class LHSType > +void upper_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const EntriesType entries, const ValuesType values, const RHSType & rhs, LHSType &lhs) { + + typedef typename TriSolveHandle::execution_space execution_space; + typedef typename TriSolveHandle::size_type size_type; + typedef typename TriSolveHandle::nnz_lno_view_t NGBLType; + + auto nlevels = thandle.get_num_levels(); + // Keep this a host View, create device version and copy to back to host during scheduling + auto nodes_per_level = thandle.get_nodes_per_level(); + auto hnodes_per_level = Kokkos::create_mirror_view(nodes_per_level); + Kokkos::deep_copy(hnodes_per_level, nodes_per_level); + + auto nodes_grouped_by_level = thandle.get_nodes_grouped_by_level(); + + size_type node_count = 0; + + // This must stay serial; would be nice to try out Cuda's graph stuff to reduce kernel launch overhead + for ( size_type lvl = 0; lvl < nlevels; ++lvl ) { + size_type lvl_nodes = hnodes_per_level(lvl); + + if ( lvl_nodes != 0 ) { + + if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP ) { + Kokkos::parallel_for( "parfor_fixed_lvl", Kokkos::RangePolicy( node_count, node_count+lvl_nodes ), UpperTriLvlSchedRPSolverFunctor (row_map, entries, values, lhs, rhs, nodes_grouped_by_level) ); + } + else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) { + typedef Kokkos::TeamPolicy policy_type; + + int team_size = thandle.get_team_size(); + if ( team_size == -1 ) { + team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 256; + } + + UpperTriLvlSchedTP1SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); + Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); + } + else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) { + typedef Kokkos::TeamPolicy tvt_policy_type; + + int team_size = thandle.get_team_size(); + if ( team_size == -1 ) { + team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 128; + } + int vector_size = thandle.get_team_size(); + if ( vector_size == -1 ) { + vector_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 4; + } + + // This impl: "chunk" lvl_nodes into node_groups; a league_rank is responsible for processing that many nodes + // TeamThreadRange over number of node_groups + // To avoid masking threads, 1 thread (team) per node in node_group + // ThreadVectorRange responsible for the actual solve computation + const int node_groups = team_size; + + UpperTriLvlSchedTP2SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count, node_groups); + Kokkos::parallel_for("parfor_u_team_vector", tvt_policy_type( (int)std::ceil((float)lvl_nodes/(float)node_groups) , team_size, vector_size ), tstf); + } // end elseif + + node_count += lvl_nodes; + + } // end if + } // end for lvl + +} // end upper_tri_solve + + +} // namespace Experimental +} // namespace Impl +} // namespace KokkosSparse + +#endif diff --git a/src/sparse/impl/KokkosSparse_sptrsv_solve_spec.hpp b/src/sparse/impl/KokkosSparse_sptrsv_solve_spec.hpp new file mode 100644 index 0000000000..7375aa4afb --- /dev/null +++ b/src/sparse/impl/KokkosSparse_sptrsv_solve_spec.hpp @@ -0,0 +1,236 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#ifndef KOKKOSSPARSE_IMPL_SPTRSV_SOLVE_SPEC_HPP_ +#define KOKKOSSPARSE_IMPL_SPTRSV_SOLVE_SPEC_HPP_ + +#include +#include +#include +#include "KokkosSparse_CrsMatrix.hpp" +#include "KokkosKernels_Handle.hpp" + +// Include the actual functors +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +#include +#include +#endif + +namespace KokkosSparse { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct sptrsv_solve_eti_spec_avail { + enum : bool { value = false }; +}; + +} +} + + +#define KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_AVAIL( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template<> \ + struct sptrsv_solve_eti_spec_avail< \ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits > > \ + { enum : bool { value = true }; }; + +// Include the actual specialization declarations +#include +#include + +namespace KokkosSparse { +namespace Impl { + +// Unification layer +/// \brief Implementation of KokkosSparse::sptrsv_solve + +template::value, + bool eti_spec_avail = + sptrsv_solve_eti_spec_avail< KernelHandle, + RowMapType, + EntriesType, + ValuesType, + BType, + XType >::value > +struct SPTRSV_SOLVE{ + static void + sptrsv_solve (KernelHandle *handle, + const RowMapType row_map, + const EntriesType entries, + const ValuesType values, + BType b, + XType x); +}; + + +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +//! Full specialization of sptrsv_solve +// Unification layer +template +struct SPTRSV_SOLVE{ + static void + sptrsv_solve (KernelHandle *handle, + const RowMapType row_map, + const EntriesType entries, + const ValuesType values, + BType b, + XType x) + { + // Call specific algorithm type + auto sptrsv_handle = handle->get_sptrsv_handle(); + + if ( sptrsv_handle->is_lower_tri() ) { + if ( sptrsv_handle->is_symbolic_complete() == false ) { + Experimental::lower_tri_symbolic(*sptrsv_handle, row_map, entries); + } + Experimental::lower_tri_solve( *sptrsv_handle, row_map, entries, values, b, x); + } + else { + if ( sptrsv_handle->is_symbolic_complete() == false ) { + Experimental::upper_tri_symbolic(*sptrsv_handle, row_map, entries); + } + Experimental::upper_tri_solve( *sptrsv_handle, row_map, entries, values, b, x); + } + } + +}; + + +#endif +} +} + +// +// Macro for declaration of full specialization of +// This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _DEF macro below) across one or +// more .cpp files. +// +#define KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_DECL( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE ) \ + extern template struct \ + SPTRSV_SOLVE<\ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, false, true >; + +#define KOKKOSSPARSE_SPTRSV_SOLVE_ETI_SPEC_INST( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template struct \ + SPTRSV_SOLVE<\ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, false, true >; + +#include +#include + + +#endif diff --git a/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp new file mode 100644 index 0000000000..2a323e580e --- /dev/null +++ b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp @@ -0,0 +1,293 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + +#ifndef KOKKOSSPARSE_IMPL_SPTRSV_SYMBOLIC_HPP_ +#define KOKKOSSPARSE_IMPL_SPTRSV_SYMBOLIC_HPP_ + +/// \file Kokkos_Sparse_impl_sptrsv_symbolic.hpp +/// \brief Implementation(s) of sparse triangular solve. + +#include +#include +#include + +//#define LVL_OUTPUT_INFO + +namespace KokkosSparse { +namespace Impl { +namespace Experimental { + + +template < class TriSolveHandle, class RowMapType, class EntriesType > +void lower_tri_symbolic ( TriSolveHandle &thandle, const RowMapType drow_map, const EntriesType dentries) { + + if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP || + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 || + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) + { + // Scheduling currently compute on host - need host copy of all views + + typedef typename TriSolveHandle::size_type size_type; + + typedef typename TriSolveHandle::nnz_lno_view_t DeviceEntriesType; + typedef typename TriSolveHandle::nnz_lno_view_t::HostMirror HostEntriesType; + + typedef typename TriSolveHandle::signed_nnz_lno_view_t DeviceSignedEntriesType; + typedef typename TriSolveHandle::signed_nnz_lno_view_t::HostMirror HostSignedEntriesType; + + typedef typename TriSolveHandle::signed_integral_t signed_integral_t; + + size_type nrows = thandle.get_nrows(); + + auto row_map = Kokkos::create_mirror_view(drow_map); + Kokkos::deep_copy(row_map, drow_map); + + auto entries = Kokkos::create_mirror_view(dentries); + Kokkos::deep_copy(entries, dentries); + + DeviceEntriesType dnodes_per_level = thandle.get_nodes_per_level(); + HostEntriesType nodes_per_level = Kokkos::create_mirror_view(dnodes_per_level); + Kokkos::deep_copy(nodes_per_level, dnodes_per_level); + + DeviceEntriesType dnodes_grouped_by_level = thandle.get_nodes_grouped_by_level(); + HostEntriesType nodes_grouped_by_level = Kokkos::create_mirror_view(dnodes_grouped_by_level); + Kokkos::deep_copy(nodes_grouped_by_level, dnodes_grouped_by_level); + + DeviceSignedEntriesType dlevel_list = thandle.get_level_list(); + HostSignedEntriesType level_list = Kokkos::create_mirror_view(dlevel_list); + Kokkos::deep_copy(level_list, dlevel_list); + + HostSignedEntriesType previous_level_list( Kokkos::ViewAllocateWithoutInitializing("previous_level_list"), nrows ); + Kokkos::deep_copy( previous_level_list, signed_integral_t(-1) ); + + + // node 0 is trivially independent in lower tri solve, start with it in level 0 + size_type level = 0; + auto starting_node = 0; + level_list(starting_node) = 0; + size_type node_count = 1; //lower tri: starting with node 0 already in level 0 + + nodes_per_level(0) = 1; + nodes_grouped_by_level(0) = starting_node; + + while (node_count < nrows) { + + for ( size_type row = 1; row < nrows; ++row ) { // row 0 already included + if ( level_list(row) == -1 ) { // unmarked + bool is_root = true; + signed_integral_t ptrstart = row_map(row); + signed_integral_t ptrend = row_map(row+1); + + for (signed_integral_t offset = ptrstart; offset < ptrend; ++offset) { + size_type col = entries(offset); + if ( previous_level_list(col) == -1 && col != row ) { // unmarked + if ( col < row ) { + is_root = false; + break; + } + } + } // end for offset , i.e. cols of this row + + if ( is_root == true ) { + level_list(row) = level; + nodes_per_level(level) += 1; + nodes_grouped_by_level(node_count) = row; + node_count += 1; + } + + } // end if + } // end for row + + //Kokkos::deep_copy(previous_level_list, level_list); + for ( size_type i = 0; i < nrows; ++i ) { + previous_level_list(i) = level_list(i); + } + + level += 1; + } // end while + + thandle.set_symbolic_complete(); + thandle.set_num_levels(level); + + // Output check +#ifdef LVL_OUTPUT_INFO + std::cout << " set symbolic complete: " << thandle.is_symbolic_complete() << std::endl; + std::cout << " set num levels: " << thandle.get_num_levels() << std::endl; + + std::cout << " lower_tri_symbolic result: " << std::endl; + for ( size_type i = 0; i < node_count; ++i ) + { std::cout << "node: " << i << " level_list = " << level_list(i) << std::endl; } + + for ( size_type i = 0; i < level; ++i ) + { std::cout << "level: " << i << " nodes_per_level = " << nodes_per_level(i) << std::endl; } + + for ( size_type i = 0; i < node_count; ++i ) + { std::cout << "i: " << i << " nodes_grouped_by_level = " << nodes_grouped_by_level(i) << std::endl; } +#endif + + Kokkos::deep_copy(dnodes_grouped_by_level, nodes_grouped_by_level); + Kokkos::deep_copy(dnodes_per_level, nodes_per_level); + Kokkos::deep_copy(dlevel_list, level_list); + } +} // end lowertri_level_sched + + +template < class TriSolveHandle, class RowMapType, class EntriesType > +void upper_tri_symbolic ( TriSolveHandle &thandle, const RowMapType drow_map, const EntriesType dentries ) { + + if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP || + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 || + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) + { + // Scheduling currently compute on host - need host copy of all views + + typedef typename TriSolveHandle::size_type size_type; + + typedef typename TriSolveHandle::nnz_lno_view_t DeviceEntriesType; + typedef typename TriSolveHandle::nnz_lno_view_t::HostMirror HostEntriesType; + + typedef typename TriSolveHandle::signed_nnz_lno_view_t DeviceSignedEntriesType; + typedef typename TriSolveHandle::signed_nnz_lno_view_t::HostMirror HostSignedEntriesType; + + typedef typename TriSolveHandle::signed_integral_t signed_integral_t; + + size_type nrows = thandle.get_nrows(); + + auto row_map = Kokkos::create_mirror_view(drow_map); + Kokkos::deep_copy(row_map, drow_map); + + auto entries = Kokkos::create_mirror_view(dentries); + Kokkos::deep_copy(entries, dentries); + + DeviceEntriesType dnodes_per_level = thandle.get_nodes_per_level(); + HostEntriesType nodes_per_level = Kokkos::create_mirror_view(dnodes_per_level); + Kokkos::deep_copy(nodes_per_level, dnodes_per_level); + + DeviceEntriesType dnodes_grouped_by_level = thandle.get_nodes_grouped_by_level(); + HostEntriesType nodes_grouped_by_level = Kokkos::create_mirror_view(dnodes_grouped_by_level); + Kokkos::deep_copy(nodes_grouped_by_level, dnodes_grouped_by_level); + + DeviceSignedEntriesType dlevel_list = thandle.get_level_list(); + HostSignedEntriesType level_list = Kokkos::create_mirror_view(dlevel_list); + Kokkos::deep_copy(level_list, dlevel_list); + + HostSignedEntriesType previous_level_list( Kokkos::ViewAllocateWithoutInitializing("previous_level_list"), nrows); + Kokkos::deep_copy( previous_level_list, signed_integral_t(-1) ); + + + // final row is trivially independent in upper tri solve, start with it in level 0 + size_type level = 0; + auto starting_node = nrows - 1; + level_list(starting_node) = 0; + size_type node_count = 1; //upper tri: starting with node n already in level 0 + + nodes_per_level(0) = 1; + nodes_grouped_by_level(0) = starting_node; + + while (node_count < nrows) { + + for ( signed_integral_t row = nrows-2; row >= 0; --row ) { // row 0 already included + if ( level_list(row) == -1 ) { // unmarked + bool is_root = true; + signed_integral_t ptrstart = row_map(row); + signed_integral_t ptrend = row_map(row+1); + + for (signed_integral_t offset = ptrend-1; offset >= ptrstart; --offset) { + signed_integral_t col = entries(offset); + if ( previous_level_list(col) == -1 && col != row ) { // unmarked + if ( col > row ) { + is_root = false; + break; + } + } + } // end for offset , i.e. cols of this row + + if ( is_root == true ) { + level_list(row) = level; + nodes_per_level(level) += 1; + nodes_grouped_by_level(node_count) = row; + node_count += 1; + } + + } // end if + } // end for row + + //Kokkos::deep_copy(previous_level_list, level_list); + for ( size_type i = 0; i < nrows; ++i ) { + previous_level_list(i) = level_list(i); + } + + level += 1; + } // end while + + thandle.set_symbolic_complete(); + thandle.set_num_levels(level); + + // Output check +#ifdef LVL_OUTPUT_INFO + std::cout << " set symbolic complete: " << thandle.is_symbolic_complete() << std::endl; + std::cout << " set num levels: " << thandle.get_num_levels() << std::endl; + + std::cout << " upper_tri_symbolic result: " << std::endl; + for ( size_type i = 0; i < node_count; ++i ) + { std::cout << "node: " << i << " level_list = " << level_list(i) << std::endl; } + + for ( size_type i = 0; i < level; ++i ) + { std::cout << "level: " << i << " nodes_per_level = " << nodes_per_level(i) << std::endl; } + + for ( size_type i = 0; i < node_count; ++i ) + { std::cout << "i: " << i << " nodes_grouped_by_level = " << nodes_grouped_by_level(i) << std::endl; } +#endif + + Kokkos::deep_copy(dnodes_grouped_by_level, nodes_grouped_by_level); + Kokkos::deep_copy(dnodes_per_level, nodes_per_level); + Kokkos::deep_copy(dlevel_list, level_list); + } +} // end uppertri_level_sched + + +} // namespace Experimental +} // namespace Impl +} // namespace KokkosSparse + +#endif diff --git a/src/sparse/impl/KokkosSparse_sptrsv_symbolic_spec.hpp b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_spec.hpp new file mode 100644 index 0000000000..f0103a2171 --- /dev/null +++ b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_spec.hpp @@ -0,0 +1,182 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ +#ifndef KOKKOSSPARSE_IMPL_SPTRSV_SYMBOLIC_SPEC_HPP_ +#define KOKKOSSPARSE_IMPL_SPTRSV_SYMBOLIC_SPEC_HPP_ + +#include +#include +#include +#include "KokkosSparse_CrsMatrix.hpp" +#include "KokkosKernels_Handle.hpp" + +// Include the actual functors +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +#include +#endif + +namespace KokkosSparse { +namespace Impl { +// Specialization struct which defines whether a specialization exists +template +struct sptrsv_symbolic_eti_spec_avail { + enum : bool { value = false }; +}; + +} +} + + +#define KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_AVAIL( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template<> \ + struct sptrsv_symbolic_eti_spec_avail< \ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits > > \ + { enum : bool { value = true }; }; + +// Include the actual specialization declarations +#include +#include + +namespace KokkosSparse { +namespace Impl { + +// Unification layer +/// \brief Implementation of KokkosSparse::sptrsv_symbolic + +template::value, + bool eti_spec_avail = + sptrsv_symbolic_eti_spec_avail< KernelHandle, + RowMapType, + EntriesType>::value > +struct SPTRSV_SYMBOLIC{ + static void + sptrsv_symbolic (KernelHandle *handle, + const RowMapType row_map, + const EntriesType entries); +}; + + +#if !defined(KOKKOSKERNELS_ETI_ONLY) || KOKKOSKERNELS_IMPL_COMPILE_LIBRARY +//! Full specialization of sptrsv_symbolic +// Unification layer +template +struct SPTRSV_SYMBOLIC{ + static void + sptrsv_symbolic (KernelHandle *handle, + const RowMapType row_map, + const EntriesType entries) + { + auto sptrsv_handle = handle->get_sptrsv_handle(); + + if ( sptrsv_handle->is_lower_tri() ) { + Experimental::lower_tri_symbolic(*sptrsv_handle, row_map, entries); + sptrsv_handle->set_symbolic_complete(); + } + else { + Experimental::upper_tri_symbolic(*sptrsv_handle, row_map, entries); + sptrsv_handle->set_symbolic_complete(); + } + } + +}; +#endif +} // namespace Impl +} // namespace KokkosSparse + +// +// Macro for declaration of full specialization of +// This is NOT for users!!! All +// the declarations of full specializations go in this header file. +// We may spread out definitions (see _DEF macro below) across one or +// more .cpp files. +// +#define KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_DECL( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE ) \ + extern template struct \ + SPTRSV_SYMBOLIC<\ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true >; \ + +#define KOKKOSSPARSE_SPTRSV_SYMBOLIC_ETI_SPEC_INST( SCALAR_TYPE, ORDINAL_TYPE, OFFSET_TYPE, LAYOUT_TYPE, EXEC_SPACE_TYPE, MEM_SPACE_TYPE) \ + template struct \ + SPTRSV_SYMBOLIC<\ + KokkosKernels::Experimental::KokkosKernelsHandle<\ + const OFFSET_TYPE, const ORDINAL_TYPE, const SCALAR_TYPE, \ + EXEC_SPACE_TYPE, MEM_SPACE_TYPE, MEM_SPACE_TYPE> , \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + Kokkos::View, \ + Kokkos::MemoryTraits >, \ + false, true > ; + +#include +#include + + +#endif diff --git a/unit_test/Makefile b/unit_test/Makefile index aaad6d6db0..12f28dbee3 100644 --- a/unit_test/Makefile +++ b/unit_test/Makefile @@ -114,6 +114,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_OPENMP), 1) OBJ_OPENMP += Test_OpenMP_Blas3_gemm.o OBJ_OPENMP += Test_OpenMP_Sparse_spmv.o OBJ_OPENMP += Test_OpenMP_Sparse_trsv.o + OBJ_OPENMP += Test_OpenMP_Sparse_sptrsv.o OBJ_OPENMP += Test_OpenMP_Sparse_spgemm.o OBJ_OPENMP += Test_OpenMP_Sparse_spadd.o OBJ_OPENMP += Test_OpenMP_Sparse_gauss_seidel.o @@ -227,6 +228,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_CUDA), 1) OBJ_CUDA += Test_Cuda_Blas_gesv.o #OBJ_CUDA += Test_Cuda_Sparse_spmv.o #OBJ_CUDA += Test_Cuda_Sparse_trsv.o #removing trsv from cuda unit test as it runs only sequential. + OBJ_CUDA += Test_Cuda_Sparse_sptrsv.o OBJ_CUDA += Test_Cuda_Sparse_spgemm.o OBJ_CUDA += Test_Cuda_Sparse_spadd.o OBJ_CUDA += Test_Cuda_Sparse_gauss_seidel.o @@ -332,6 +334,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_SERIAL), 1) OBJ_SERIAL += Test_Serial_Blas3_gemm.o OBJ_SERIAL += Test_Serial_Sparse_spmv.o OBJ_SERIAL += Test_Serial_Sparse_trsv.o + OBJ_SERIAL += Test_Serial_Sparse_sptrsv.o OBJ_SERIAL += Test_Serial_Sparse_spgemm.o OBJ_SERIAL += Test_Serial_Sparse_spadd.o OBJ_SERIAL += Test_Serial_Sparse_gauss_seidel.o @@ -444,6 +447,7 @@ ifeq ($(KOKKOSKERNELS_INTERNAL_TEST_THREADS), 1) OBJ_THREADS += Test_Threads_Blas3_gemm.o OBJ_THREADS += Test_Threads_Sparse_spmv.o OBJ_THREADS += Test_Threads_Sparse_trsv.o + OBJ_THREADS += Test_Threads_Sparse_sptrsv.o OBJ_THREADS += Test_Threads_Sparse_spgemm.o OBJ_THREADS += Test_Threads_Sparse_spadd.o OBJ_THREADS += Test_Threads_Sparse_gauss_seidel.o diff --git a/unit_test/cuda/Test_Cuda_Sparse_sptrsv.cpp b/unit_test/cuda/Test_Cuda_Sparse_sptrsv.cpp new file mode 100644 index 0000000000..a396830207 --- /dev/null +++ b/unit_test/cuda/Test_Cuda_Sparse_sptrsv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/openmp/Test_OpenMP_Sparse_sptrsv.cpp b/unit_test/openmp/Test_OpenMP_Sparse_sptrsv.cpp new file mode 100644 index 0000000000..3d0cdffe46 --- /dev/null +++ b/unit_test/openmp/Test_OpenMP_Sparse_sptrsv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/serial/Test_Serial_Sparse_sptrsv.cpp b/unit_test/serial/Test_Serial_Sparse_sptrsv.cpp new file mode 100644 index 0000000000..de98609355 --- /dev/null +++ b/unit_test/serial/Test_Serial_Sparse_sptrsv.cpp @@ -0,0 +1,2 @@ +#include +#include diff --git a/unit_test/sparse/Test_Sparse_sptrsv.hpp b/unit_test/sparse/Test_Sparse_sptrsv.hpp new file mode 100644 index 0000000000..a98377abdc --- /dev/null +++ b/unit_test/sparse/Test_Sparse_sptrsv.hpp @@ -0,0 +1,703 @@ +/* +//@HEADER +// ************************************************************************ +// +// KokkosKernels 0.9: Linear Algebra and Graph Kernels +// Copyright 2017 Sandia Corporation +// +// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +// the U.S. Government retains certain rights in this software. +// +// 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. +// +// 3. Neither the name of the Corporation nor the names of the +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE +// 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. +// +// Questions? Contact Siva Rajamanickam (srajama@sandia.gov) +// +// ************************************************************************ +//@HEADER +*/ + + +#include +#include + +#include +#include +#include + +#include "KokkosKernels_SparseUtils.hpp" +#include "KokkosSparse_spmv.hpp" +#include "KokkosSparse_CrsMatrix.hpp" +#include + +#include "KokkosSparse_sptrsv.hpp" + +#include + + +using namespace KokkosSparse; +using namespace KokkosSparse::Experimental; +using namespace KokkosKernels; +using namespace KokkosKernels::Experimental; + +#ifndef kokkos_complex_double +#define kokkos_complex_double Kokkos::complex +#define kokkos_complex_float Kokkos::complex +#endif + +namespace Test { + +#if 0 +template +void run_test_sptrsv_mtx() { + + typedef typename KokkosSparse::CrsMatrix crsmat_t; + typedef typename crsmat_t::StaticCrsGraphType graph_t; + + //typedef Kokkos::View< size_type*, device > RowMapType; + //typedef Kokkos::View< lno_t*, device > EntriesType; + typedef Kokkos::View< scalar_t*, device > ValuesType; + + // Lower tri + std::cout << "LowerTriTest Begin" << std::endl; + { + +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/L-offshore-amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/L-Transport-amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/L-Fault_639amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/L-thermal2-amd.mtx"; + std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/L-dielFilterV2real-amd.mtx"; + std::cout << "Matrix file: " << mtx_filename << std::endl; + crsmat_t triMtx = KokkosKernels::Impl::read_kokkos_crst_matrix(mtx_filename.c_str()); //in_matrix + graph_t lgraph = triMtx.graph; // in_graph + + auto row_map = lgraph.row_map; + auto entries = lgraph.entries; + auto values = triMtx.values; + + const size_type nrows = lgraph.numRows(); +// const size_type nnz = triMtx.nnz(); + + scalar_t ZERO = scalar_t(0); + scalar_t ONE = scalar_t(1); + + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + + std::cout << "UnitTest nrows = " << nrows << std::endl; + + KernelHandle kh; + bool is_lower_tri = true; + std::cout << "Create handle" << std::endl; + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + + std::cout << "Prepare linear system" << std::endl; + // Create known_lhs, generate rhs, then solve for lhs to compare to known_lhs + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + +// typedef CrsMatrix crsMat_t; +// crsMat_t triMtx("triMtx", nrows, nrows, nnz, values, row_map, entries); + + std::cout << "SPMV" << std::endl; + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + std::cout << "TriSolve Symbolic" << std::endl; + Kokkos::Timer timer; + sptrsv_symbolic( &kh, row_map, entries ); + std::cout << "LTRI Symbolic Time: " << timer.seconds() << std::endl; + + std::cout << "TriSolve Solve" << std::endl; + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "LTRI Solve TEAMPOLICY! Time: " << timer.seconds() << std::endl; + + scalar_t sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHD_RP); + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "LTRI Solve SEQLVLSCHD_RP Time: " << timer.seconds() << std::endl; + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "LTRI Solve SEQLVLSCHED_TP2 Time: " << timer.seconds() << std::endl; + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + + kh.destroy_sptrsv_handle(); + } + // Upper tri + std::cout << "UpperTriTest Begin" << std::endl; + { +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/U-offshore-amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/U-Transport-amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/U-Fault_639amd.mtx"; +// std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/U-thermal2-amd.mtx"; + std::string mtx_filename = "/ascldap/users/ndellin/TestCodes-GitlabEx/KokkosEcoCodes/KokkosKernels-DevTests/Matrices/U-dielFilterV2real-amd.mtx"; + std::cout << "Matrix file: " << mtx_filename << std::endl; + crsmat_t triMtx = KokkosKernels::Impl::read_kokkos_crst_matrix(mtx_filename.c_str()); //in_matrix + graph_t lgraph = triMtx.graph; // in_graph + + auto row_map = lgraph.row_map; + auto entries = lgraph.entries; + auto values = triMtx.values; + + const size_type nrows = lgraph.numRows(); +// const size_type nnz = triMtx.nnz(); + + scalar_t ZERO = scalar_t(0); + scalar_t ONE = scalar_t(1); + + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + + std::cout << "UnitTest nrows = " << nrows << std::endl; + + KernelHandle kh; + bool is_lower_tri = false; + std::cout << "Create handle" << std::endl; + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + + std::cout << "Prepare linear system" << std::endl; + // Create known_lhs, generate rhs, then solve for lhs to compare to known_lhs + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + +// typedef CrsMatrix crsMat_t; +// crsMat_t triMtx("triMtx", nrows, nrows, nnz, values, row_map, entries); + std::cout << "SPMV" << std::endl; + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + std::cout << "TriSolve Symbolic" << std::endl; + Kokkos::Timer timer; + sptrsv_symbolic( &kh, row_map, entries ); + std::cout << "UTRI Symbolic Time: " << timer.seconds() << std::endl; + + std::cout << "TriSolve Solve" << std::endl; + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "UTRI Solve SEQLVLSCHD_TP1 Time: " << timer.seconds() << std::endl; + + scalar_t sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHD_RP); + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "UTRI Solve SEQLVLSCHD_RP Time: " << timer.seconds() << std::endl; + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); + kh.get_sptrsv_handle()->print_algorithm(); + timer.reset(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + std::cout << "UTRI Solve SEQLVLSCHED_TP2 Time: " << timer.seconds() << std::endl; + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), KOKKOS_LAMBDA ( const lno_t i, scalar_t &tsum ) { + tsum += lhs(i); + }, sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + //std::cout << "Num-levels = " << kh->get_sptrsv_handle()->get_num_levels() << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + + kh.destroy_sptrsv_handle(); + } + +} +#endif + + +template < class ViewType, typename ValueType, typename OrdinalType > +struct ReductionCheck { + + using lno_t = OrdinalType; + using value_type = ValueType; + + ViewType lhs; + + ReductionCheck( const ViewType & lhs_ ) : lhs(lhs_) {} + + KOKKOS_INLINE_FUNCTION + void operator()( lno_t i, value_type &tsum ) const { + tsum += lhs(i); + } + +}; + + +template +void run_test_sptrsv() { + + typedef Kokkos::View< size_type*, device > RowMapType; + typedef Kokkos::View< lno_t*, device > EntriesType; + typedef Kokkos::View< scalar_t*, device > ValuesType; + + // Lower tri + { + const size_type nrows = 5; + const size_type nnz = 10; + + RowMapType row_map("row_map", nrows+1); + EntriesType entries("entries", nnz); + ValuesType values("values", nnz); + + auto hrow_map = Kokkos::create_mirror_view(row_map); + auto hentries = Kokkos::create_mirror_view(entries); + auto hvalues = Kokkos::create_mirror_view(values); + + scalar_t ZERO = scalar_t(0); + scalar_t ONE = scalar_t(1); + + hrow_map(0) = 0; + hrow_map(1) = 1; + hrow_map(2) = 2; + hrow_map(3) = 4; + hrow_map(4) = 6; + hrow_map(5) = 10; + + hentries(0) = 0; + hentries(1) = 1; + hentries(2) = 0; + hentries(3) = 2; + hentries(4) = 2; + hentries(5) = 3; + hentries(6) = 1; + hentries(7) = 2; + hentries(8) = 3; + hentries(9) = 4; + + for ( size_type i = 0; i < nnz; ++i ) { + hvalues(i) = ONE; + } + + Kokkos::deep_copy(row_map, hrow_map); + Kokkos::deep_copy(entries, hentries); + Kokkos::deep_copy(values, hvalues); + + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + + KernelHandle kh; + bool is_lower_tri = true; + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + + // Create known_lhs, generate rhs, then solve for lhs to compare to known_lhs + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + + typedef CrsMatrix crsMat_t; + crsMat_t triMtx("triMtx", nrows, nrows, nnz, values, row_map, entries); + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + sptrsv_symbolic( &kh, row_map, entries ); + Kokkos::fence(); + + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + scalar_t sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHD_RP); + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + +#if !defined(KOKKOS_ENABLE_CUDA) +//FIXME Issues with various integral type combos + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Lower Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Lower Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); +#endif + + + kh.destroy_sptrsv_handle(); + } + // Upper tri + { + const size_type nrows = 5; + const size_type nnz = 10; + + RowMapType row_map("row_map", nrows+1); + EntriesType entries("entries", nnz); + ValuesType values("values", nnz); + + auto hrow_map = Kokkos::create_mirror_view(row_map); + auto hentries = Kokkos::create_mirror_view(entries); + auto hvalues = Kokkos::create_mirror_view(values); + + scalar_t ZERO = scalar_t(0); + scalar_t ONE = scalar_t(1); + + hrow_map(0) = 0; + hrow_map(1) = 2; + hrow_map(2) = 4; + hrow_map(3) = 7; + hrow_map(4) = 9; + hrow_map(5) = 10; + + hentries(0) = 0; + hentries(1) = 2; + hentries(2) = 1; + hentries(3) = 4; + hentries(4) = 2; + hentries(5) = 3; + hentries(6) = 4; + hentries(7) = 3; + hentries(8) = 4; + hentries(9) = 4; + + for ( size_type i = 0; i < nnz; ++i ) { + hvalues(i) = ONE; + } + + Kokkos::deep_copy(row_map, hrow_map); + Kokkos::deep_copy(entries, hentries); + Kokkos::deep_copy(values, hvalues); + + typedef KokkosKernels::Experimental::KokkosKernelsHandle KernelHandle; + + KernelHandle kh; + bool is_lower_tri = false; + kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); + + // Create known_lhs, generate rhs, then solve for lhs to compare to known_lhs + ValuesType known_lhs("known_lhs", nrows); + // Create known solution lhs set to all 1's + Kokkos::deep_copy(known_lhs, ONE); + + // Solution to find + ValuesType lhs("lhs", nrows); + + // A*known_lhs generates rhs: rhs is dense, use spmv + ValuesType rhs("rhs", nrows); + + typedef CrsMatrix crsMat_t; + crsMat_t triMtx("triMtx", nrows, nrows, nnz, values, row_map, entries); + KokkosSparse::spmv( "N", ONE, triMtx, known_lhs, ZERO, rhs); + + sptrsv_symbolic( &kh, row_map, entries ); + Kokkos::fence(); + + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + scalar_t sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHD_RP); + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); + +#if !defined(KOKKOS_ENABLE_CUDA) +//FIXME Issues with various integral type combos + Kokkos::deep_copy(lhs, 0); + kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); + kh.get_sptrsv_handle()->print_algorithm(); + sptrsv_solve( &kh, row_map, entries, values, rhs, lhs ); + Kokkos::fence(); + + sum = 0.0; + Kokkos::parallel_reduce( Kokkos::RangePolicy(0, lhs.extent(0)), ReductionCheck(lhs), sum); + if ( sum != lhs.extent(0) ) { + std::cout << "Upper Tri Solve FAILURE" << std::endl; + } + else { + std::cout << "Upper Tri Solve SUCCESS!" << std::endl; + } + EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); +#endif + + + kh.destroy_sptrsv_handle(); + } + +} + +} // namespace Test + +template +void test_sptrsv() { + Test::run_test_sptrsv(); +// Test::run_test_sptrsv_mtx(); +} + + +#define EXECUTE_TEST(SCALAR, ORDINAL, OFFSET, DEVICE) \ +TEST_F( TestCategory, sparse ## _ ## sptrsv ## _ ## SCALAR ## _ ## ORDINAL ## _ ## OFFSET ## _ ## DEVICE ) { \ + test_sptrsv(); \ +} + + +#if (defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(double, int, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(double, int64_t, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(double, int, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_DOUBLE) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(double, int64_t, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(float, int, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(float, int64_t, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(float, int, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_FLOAT) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(float, int64_t, size_t, TestExecSpace) +#endif + +#if 0 + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_double, int, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_double, int64_t, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_double, int, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_DOUBLE_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_double, int64_t, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_float, int, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_INT) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_float, int64_t, int, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_float, int, size_t, TestExecSpace) +#endif + +#if (defined (KOKKOSKERNELS_INST_KOKKOS_COMPLEX_FLOAT_) \ + && defined (KOKKOSKERNELS_INST_ORDINAL_INT64_T) \ + && defined (KOKKOSKERNELS_INST_OFFSET_SIZE_T) ) || (!defined(KOKKOSKERNELS_ETI_ONLY) && !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS)) + EXECUTE_TEST(kokkos_complex_float, int64_t, size_t, TestExecSpace) +#endif + +#endif diff --git a/unit_test/threads/Test_Threads_Sparse_sptrsv.cpp b/unit_test/threads/Test_Threads_Sparse_sptrsv.cpp new file mode 100644 index 0000000000..61906d4698 --- /dev/null +++ b/unit_test/threads/Test_Threads_Sparse_sptrsv.cpp @@ -0,0 +1,2 @@ +#include +#include From 29a0bebe0792d2ef925e3a5fae25835e4fb45b67 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Mon, 17 Jun 2019 10:39:56 -0600 Subject: [PATCH 186/190] sptrsv: Disable TP2 algorithm, address comments 3-level parallelism kernel commented out and unavailable until issues resolved with some offset-ordinal pairs. --- src/common/KokkosKernels_Handle.hpp | 2 +- src/sparse/KokkosSparse_sptrsv.hpp | 14 +++++++------- src/sparse/KokkosSparse_sptrsv_handle.hpp | 12 ++++++++---- src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp | 6 ++++++ .../impl/KokkosSparse_sptrsv_symbolic_impl.hpp | 8 ++++---- unit_test/sparse/Test_Sparse_sptrsv.hpp | 12 ++++++------ 6 files changed, 32 insertions(+), 22 deletions(-) diff --git a/src/common/KokkosKernels_Handle.hpp b/src/common/KokkosKernels_Handle.hpp index 33fcd140a5..d098911f74 100644 --- a/src/common/KokkosKernels_Handle.hpp +++ b/src/common/KokkosKernels_Handle.hpp @@ -523,7 +523,7 @@ class KokkosKernelsHandle this->destroy_sptrsv_handle(); this->is_owner_of_the_sptrsv_handle = true; this->sptrsvHandle = new SPTRSVHandleType(algm, nrows, lower_tri); - this->sptrsvHandle->reset_handle_views(nrows); + this->sptrsvHandle->reset_handle(nrows); this->sptrsvHandle->set_team_size(this->team_work_size); this->sptrsvHandle->set_vector_size(this->vector_size); } diff --git a/src/sparse/KokkosSparse_sptrsv.hpp b/src/sparse/KokkosSparse_sptrsv.hpp index 6677e779b5..94a86f2f8c 100644 --- a/src/sparse/KokkosSparse_sptrsv.hpp +++ b/src/sparse/KokkosSparse_sptrsv.hpp @@ -61,7 +61,7 @@ namespace KokkosSparse { namespace Experimental { -#define SAME_TYPE(A, B) std::is_same::type, typename std::remove_const::type>::value +#define KOKKOSKERNELS_SPTRSV_SAME_TYPE(A, B) std::is_same::type, typename std::remove_const::type>::value template ::value, @@ -217,7 +217,7 @@ namespace Experimental { } // namespace Experimental } // namespace KokkosSparse -#undef SAME_TYPE +#undef KOKKOSKERNELS_SPTRSV_SAME_TYPE #endif // KOKKOSSPARSE_SPTRSV_HPP_ diff --git a/src/sparse/KokkosSparse_sptrsv_handle.hpp b/src/sparse/KokkosSparse_sptrsv_handle.hpp index c378149219..005ad8d828 100644 --- a/src/sparse/KokkosSparse_sptrsv_handle.hpp +++ b/src/sparse/KokkosSparse_sptrsv_handle.hpp @@ -52,7 +52,8 @@ namespace KokkosSparse { namespace Experimental { -enum class SPTRSVAlgorithm { SEQLVLSCHD_RP, SEQLVLSCHD_TP1, SEQLVLSCHED_TP2 }; +// TP2 algorithm has issues with some offset-ordinal combo to be addressed +enum class SPTRSVAlgorithm { SEQLVLSCHD_RP, SEQLVLSCHD_TP1/*, SEQLVLSCHED_TP2*/ }; template tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); } + /* + // TP2 algorithm has issues with some offset-ordinal combo to be addressed else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) { typedef Kokkos::TeamPolicy tvt_policy_type; @@ -601,6 +603,7 @@ void lower_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const LowerTriLvlSchedTP2SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count, node_groups); Kokkos::parallel_for("parfor_u_team_vector", tvt_policy_type( (int)std::ceil((float)lvl_nodes/(float)node_groups) , team_size, vector_size ), tstf); } // end elseif + */ node_count += lvl_nodes; @@ -647,6 +650,8 @@ void upper_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const UpperTriLvlSchedTP1SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); } + /* + // TP2 algorithm has issues with some offset-ordinal combo to be addressed else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) { typedef Kokkos::TeamPolicy tvt_policy_type; @@ -668,6 +673,7 @@ void upper_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const UpperTriLvlSchedTP2SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count, node_groups); Kokkos::parallel_for("parfor_u_team_vector", tvt_policy_type( (int)std::ceil((float)lvl_nodes/(float)node_groups) , team_size, vector_size ), tstf); } // end elseif + */ node_count += lvl_nodes; diff --git a/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp index 2a323e580e..2335f68dea 100644 --- a/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp +++ b/src/sparse/impl/KokkosSparse_sptrsv_symbolic_impl.hpp @@ -62,8 +62,8 @@ template < class TriSolveHandle, class RowMapType, class EntriesType > void lower_tri_symbolic ( TriSolveHandle &thandle, const RowMapType drow_map, const EntriesType dentries) { if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP || - thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 || - thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) +/* || thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 )*/ { // Scheduling currently compute on host - need host copy of all views @@ -176,8 +176,8 @@ template < class TriSolveHandle, class RowMapType, class EntriesType > void upper_tri_symbolic ( TriSolveHandle &thandle, const RowMapType drow_map, const EntriesType dentries ) { if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_RP || - thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 || - thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 ) + thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) +/* || thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHED_TP2 )*/ { // Scheduling currently compute on host - need host copy of all views diff --git a/unit_test/sparse/Test_Sparse_sptrsv.hpp b/unit_test/sparse/Test_Sparse_sptrsv.hpp index a98377abdc..27b447cd2c 100644 --- a/unit_test/sparse/Test_Sparse_sptrsv.hpp +++ b/unit_test/sparse/Test_Sparse_sptrsv.hpp @@ -443,8 +443,8 @@ void run_test_sptrsv() { } EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); -#if !defined(KOKKOS_ENABLE_CUDA) -//FIXME Issues with various integral type combos +/* +//FIXME Issues with various integral type combos - algorithm currently unavailable and commented out until fixed Kokkos::deep_copy(lhs, 0); kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); kh.get_sptrsv_handle()->print_algorithm(); @@ -460,7 +460,7 @@ void run_test_sptrsv() { std::cout << "Lower Tri Solve SUCCESS!" << std::endl; } EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); -#endif +*/ kh.destroy_sptrsv_handle(); @@ -562,8 +562,8 @@ void run_test_sptrsv() { } EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); -#if !defined(KOKKOS_ENABLE_CUDA) -//FIXME Issues with various integral type combos +/* +//FIXME Issues with various integral type combos - algorithm currently unavailable and commented out until fixed Kokkos::deep_copy(lhs, 0); kh.get_sptrsv_handle()->set_algorithm(SPTRSVAlgorithm::SEQLVLSCHED_TP2); kh.get_sptrsv_handle()->print_algorithm(); @@ -579,7 +579,7 @@ void run_test_sptrsv() { std::cout << "Upper Tri Solve SUCCESS!" << std::endl; } EXPECT_TRUE( sum == scalar_t(lhs.extent(0)) ); -#endif +*/ kh.destroy_sptrsv_handle(); From b3f41db9d1460fd2fe7401acae8960c81ffac80c Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Mon, 17 Jun 2019 09:50:48 -0700 Subject: [PATCH 187/190] sptrsv: disable 3-level algm from perf test --- perf_test/sparse/KokkosSparse_sptrsv.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/perf_test/sparse/KokkosSparse_sptrsv.cpp b/perf_test/sparse/KokkosSparse_sptrsv.cpp index 1f86a17a52..93e1d1a85f 100644 --- a/perf_test/sparse/KokkosSparse_sptrsv.cpp +++ b/perf_test/sparse/KokkosSparse_sptrsv.cpp @@ -70,7 +70,7 @@ using namespace KokkosSparse::Experimental; using namespace KokkosKernels; using namespace KokkosKernels::Experimental; -enum {DEFAULT, CUSPARSE, LVLSCHED_RP, LVLSCHED_TP1, LVLSCHED_TP2}; +enum {DEFAULT, CUSPARSE, LVLSCHED_RP, LVLSCHED_TP1/*, LVLSCHED_TP2*/}; @@ -192,15 +192,17 @@ int test_sptrsv_perf(std::vector tests, std::string& lfilename, std::string kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); kh.get_sptrsv_handle()->print_algorithm(); break; +/* case LVLSCHED_TP2: kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHED_TP2, nrows, is_lower_tri); kh.get_sptrsv_handle()->print_algorithm(); break; +*/ #ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE case CUSPARSE: std::cout << "CUSPARSE: No kk interface added yet" << std::endl; //cusparse_matvec(A, x, y, rows_per_thread, team_size, vector_length); - break; + break; #endif default: kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); @@ -413,10 +415,12 @@ int test_sptrsv_perf(std::vector tests, std::string& lfilename, std::string kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHD_TP1, nrows, is_lower_tri); kh.get_sptrsv_handle()->print_algorithm(); break; +/* case LVLSCHED_TP2: kh.create_sptrsv_handle(SPTRSVAlgorithm::SEQLVLSCHED_TP2, nrows, is_lower_tri); kh.get_sptrsv_handle()->print_algorithm(); break; +*/ #ifdef KOKKOSKERNELS_ENABLE_TPL_CUSPARSE case CUSPARSE: std::cout << "CUSPARSE: No kk interface added yet" << std::endl; @@ -597,9 +601,11 @@ int main(int argc, char **argv) if((strcmp(argv[i],"lvltp1")==0)) { tests.push_back( LVLSCHED_TP1 ); } +/* if((strcmp(argv[i],"lvltp2")==0)) { tests.push_back( LVLSCHED_TP2 ); } +*/ if((strcmp(argv[i],"cusparse")==0)) { tests.push_back( CUSPARSE ); } From e66c5492920beea9dfcb72e175350983f1f68e80 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Thu, 20 Jun 2019 14:52:04 -0600 Subject: [PATCH 188/190] Update trilinos integration scripts and notes --- doc/kokkos-promotion.txt | 19 +++++- .../configure-atdm-cuda-depoff-dbg.sh | 53 ++++++++++++++++ .../configure-atdm-cuda-depoff-rdc.sh | 63 +++++++++++++++++++ .../configure-atdm-cuda-depoff.sh | 58 +++++++++++++++++ .../configure-atdm-cuda-depon-dbg.sh | 54 ++++++++++++++++ .../configure-atdm-cuda-depon-rdc-dbg.sh | 59 +++++++++++++++++ .../configure-atdm-cuda-depon.sh | 57 +++++++++++++++++ .../ATDM_configurations/configure-atdm-env.sh | 58 +++++++++++++++++ .../white_run_jenkins_script_cuda-kepler | 2 +- .../white_run_jenkins_script_cuda-pascal | 2 +- ..._jenkins_script_cuda_serial_complex-kepler | 2 +- .../white_run_jenkins_script_omp | 2 +- 12 files changed, 423 insertions(+), 6 deletions(-) create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-dbg.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-rdc.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-dbg.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-rdc-dbg.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon.sh create mode 100755 scripts/trilinos-integration/ATDM_configurations/configure-atdm-env.sh diff --git a/doc/kokkos-promotion.txt b/doc/kokkos-promotion.txt index 9366ee6b33..3ed8aa0040 100644 --- a/doc/kokkos-promotion.txt +++ b/doc/kokkos-promotion.txt @@ -70,13 +70,28 @@ supported compilers. Those machines are: // -------------------------------------------------------------------------------- // Step 2: - 2.1. Build and test Trilinos with 4 different configurations; Run scripts for white and blake that are provided in kokkos-kernels/scripts/trilinos-integration. These scripts load their own modules/environment, so don't require preparation. You can run all four at the same time, use separate directories for each. + 2.1. Build and test Trilinos with the following configurations: + a) serial, openmp, and cuda via the testing scripts in kokkos-kernels/scripts/trilinos-integration (automates the process) + b) various ATDM-supported builds via Trilinos configuration scripts located in kokkos{-kernels}/scripts/trilinos-integration/ATDM_configurations (not yet automated) + + Run scripts for white (openmp and cuda) and blake (seral) that are provided in kokkos{-kernels}/scripts/trilinos-integration. + These scripts load their own modules/environment, so don't require preparation. You can run all four at the same time, use separate directories for each. mkdir serial cd serial nohup KOKKOSKERNELS_PATH/scripts/trilinos-integration/blake_jenkins_run_script_serial_intel & - 2.2. Compare the compile errors and test failures between updated and pristine versions. There may be compile failures that happen in both, tests that fail in both, and there may be tests that only fail some times (thus, rerun tests manually as needed). + Use scripts to configure Trilinos for waterman (cuda, cuda-debug, cuda-rdc) that are provided in kokkos-kernels/scripts/trilinos-integration/ATDM_configurations. + + These scripts load their own modules/environment, so don't require preparation of the system environment. You can run all them all at the same time, use separate directories for each. Instructions for compute node allocation, building, and testing are included in the scripts. + + The Trilinos configuration scripts include an override of the kokkos and kokkos-kernels packages; this requires that a symbolic link for each be created in the Trilinos base directory: + + cd Trilinos + ln -s kokkos + ln -s kokkos-kernels + + 2.2. Compare the compile errors and test failures between updated and pristine versions; the ATDM configurations scripts should have 0 build errors and 100% passing tests. There may be compile failures that happen in both, tests that fail in both, and there may be tests that only fail some times (thus, rerun tests manually as needed). // -------------------------------------------------------------------------------- // diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-dbg.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-dbg.sh new file mode 100755 index 0000000000..375b7f8712 --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-dbg.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-dbg + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=OFF \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ + -DTpetra_ENABLE_DEBUG=ON \ +$TRILINOS_DIR + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestCompare-DepOffdbg -W 06:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-rdc.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-rdc.sh new file mode 100755 index 0000000000..5e0e107a41 --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff-rdc.sh @@ -0,0 +1,63 @@ +#!/bin/bash + +echo "SOURCE this script!!" + +#export TRILINOS_DIR=${HOME}/trilinos/Trilinos +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-rdc-opt +#module swap cmake/3.6.2 cmake/3.12.3 +#source $TRILINOS_DIR/cmake/std/atdm/load-env.sh cuda-9.2-debug-Kepler37 + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + + +rm -rf CMake* + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKokkos_ENABLE_Cuda_Relocatable_Device_Code=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=OFF \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ +$TRILINOS_DIR + +# -DTrilinos_ENABLE_TESTS=ON -DTrilinos_ENABLE_${PACKAGE1}=ON \ +# -DKOKKOS_ENABLE_RELOCATABLE_DEVICE_CODE=ON \ + +# Notes: Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestKokkos-DepCodeOn -W 07:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j16 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j16 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff.sh new file mode 100755 index 0000000000..9f35eeed3f --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depoff.sh @@ -0,0 +1,58 @@ +#!/bin/bash + +echo "SOURCE this script!!" + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-opt + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + + +rm -rf CMake* + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=OFF \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ +$TRILINOS_DIR + + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestCompare-DepCodeOFF -W 06:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Or submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-dbg.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-dbg.sh new file mode 100755 index 0000000000..41160c938c --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-dbg.sh @@ -0,0 +1,54 @@ +#!/bin/bash + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-dbg + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=ON \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ + -DTpetra_ENABLE_DEBUG=ON \ +$TRILINOS_DIR + + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestCompare-DepOndbg -W 06:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-rdc-dbg.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-rdc-dbg.sh new file mode 100755 index 0000000000..d910ea658f --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon-rdc-dbg.sh @@ -0,0 +1,59 @@ +#!/bin/bash + +echo "SOURCE this script!!" + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-rdc-debug + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + + +rm -rf CMake* + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=ON \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ + -DKokkos_ENABLE_Cuda_Relocatable_Device_Code=ON \ +$TRILINOS_DIR + + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestKokkos-DepCodeOn -W 07:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon.sh new file mode 100755 index 0000000000..955821005f --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-cuda-depon.sh @@ -0,0 +1,57 @@ +#!/bin/bash + +echo "SOURCE this script!!" + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh cuda-9.2-opt + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + + +rm -rf CMake* + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=ON \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ +$TRILINOS_DIR + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestKokkos-DepCodeOn -W 07:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/ATDM_configurations/configure-atdm-env.sh b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-env.sh new file mode 100755 index 0000000000..76e0391912 --- /dev/null +++ b/scripts/trilinos-integration/ATDM_configurations/configure-atdm-env.sh @@ -0,0 +1,58 @@ +#!/bin/bash + +echo "SOURCE this script!!" + +export TRILINOS_DIR=${PWD}/../.. + +# Load modules +module purge +source ${TRILINOS_DIR}/cmake/std/atdm/load-env.sh Trilinos-atdm-waterman-cuda-9.2-rdc-release-debug-pt + +# Packages +PACKAGE1=Tpetra +PACKAGE2=Sacado +PACKAGE3=Stokhos +PACKAGE4=MueLu +PACKAGE5=Intrepid2 +PACKAGE6=Ifpack2 +PACKAGE7=Panzer +PACKAGE8=Phalanx +PACKAGE9=Stratimikos +PACKAGE10=Belos + + +rm -rf CMake* + +# Configure +cmake \ + -GNinja \ + -DTrilinos_CONFIGURE_OPTIONS_FILE:STRING=cmake/std/atdm/ATDMDevEnv.cmake \ + -DTrilinos_ENABLE_TESTS=ON \ + -DTrilinos_ENABLE_${PACKAGE1}=ON \ + -DTrilinos_ENABLE_${PACKAGE2}=ON \ + -DTrilinos_ENABLE_${PACKAGE3}=ON \ + -DTrilinos_ENABLE_${PACKAGE4}=ON \ + -DTrilinos_ENABLE_${PACKAGE5}=ON \ + -DTrilinos_ENABLE_${PACKAGE6}=ON \ + -DTrilinos_ENABLE_${PACKAGE7}=ON \ + -DTrilinos_ENABLE_${PACKAGE8}=ON \ + -DTrilinos_ENABLE_${PACKAGE9}=ON \ + -DTrilinos_ENABLE_${PACKAGE10}=ON \ + -DKOKKOS_ENABLE_DEPRECATED_CODE=ON \ + -DKokkos_SOURCE_DIR_OVERRIDE:STRING=kokkos \ + -DKokkosKernels_SOURCE_DIR_OVERRIDE:STRING=kokkos-kernels \ +$TRILINOS_DIR + + +# Notes: +# Compile using ninja +# make NP=32 + +# Allocate node: +# bsub -J TestKokkos-DepCodeOn -W 07:00 -Is -n 16 -q rhel7W bash + +# Run tests +# ctest -j8 + +# Submit tests as job +# bsub -x -Is -q rhel7W -n 16 ctest -j8 diff --git a/scripts/trilinos-integration/white_run_jenkins_script_cuda-kepler b/scripts/trilinos-integration/white_run_jenkins_script_cuda-kepler index e880e24ae1..3fa43af5fa 100755 --- a/scripts/trilinos-integration/white_run_jenkins_script_cuda-kepler +++ b/scripts/trilinos-integration/white_run_jenkins_script_cuda-kepler @@ -43,7 +43,7 @@ export JENKINS_DO_EXAMPLES=ON export QUEUE=rhel7F -module load python +module load python/2.7.12 export KOKKOSKERNELS_PATH=${PWD}/kokkos-kernels diff --git a/scripts/trilinos-integration/white_run_jenkins_script_cuda-pascal b/scripts/trilinos-integration/white_run_jenkins_script_cuda-pascal index d44b287162..ecec1ff2bb 100755 --- a/scripts/trilinos-integration/white_run_jenkins_script_cuda-pascal +++ b/scripts/trilinos-integration/white_run_jenkins_script_cuda-pascal @@ -43,7 +43,7 @@ export JENKINS_DO_EXAMPLES=ON export QUEUE=rhel7G -module load python +module load python/2.7.12 export KOKKOSKERNELS_PATH=${PWD}/kokkos-kernels diff --git a/scripts/trilinos-integration/white_run_jenkins_script_cuda_serial_complex-kepler b/scripts/trilinos-integration/white_run_jenkins_script_cuda_serial_complex-kepler index 603fafdeec..30e5d0cadd 100755 --- a/scripts/trilinos-integration/white_run_jenkins_script_cuda_serial_complex-kepler +++ b/scripts/trilinos-integration/white_run_jenkins_script_cuda_serial_complex-kepler @@ -43,7 +43,7 @@ export JENKINS_DO_EXAMPLES=ON export QUEUE=rhel7F -module load python +module load python/2.7.12 export KOKKOSKERNELS_PATH=${PWD}/kokkos-kernels diff --git a/scripts/trilinos-integration/white_run_jenkins_script_omp b/scripts/trilinos-integration/white_run_jenkins_script_omp index 2481264f41..e5c767823e 100755 --- a/scripts/trilinos-integration/white_run_jenkins_script_omp +++ b/scripts/trilinos-integration/white_run_jenkins_script_omp @@ -43,7 +43,7 @@ export JENKINS_DO_EXAMPLES=ON export QUEUE=rhel7F -module load python +module load python/2.7.12 export KOKKOSKERNELS_PATH=${PWD}/kokkos-kernels From af554a87cb76068feb78c87738a9b10801a4a176 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Mon, 24 Jun 2019 11:51:57 -0600 Subject: [PATCH 189/190] sptrsv: Fix for team_size Detected during 2.9 Trilinos integration testing --- .../impl/KokkosSparse_sptrsv_solve_impl.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp b/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp index b22538a2ba..417acc223a 100644 --- a/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp +++ b/src/sparse/impl/KokkosSparse_sptrsv_solve_impl.hpp @@ -573,12 +573,12 @@ void lower_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const else if ( thandle.get_algorithm() == KokkosSparse::Experimental::SPTRSVAlgorithm::SEQLVLSCHD_TP1 ) { typedef Kokkos::TeamPolicy policy_type; int team_size = thandle.get_team_size(); - if ( team_size == -1 ) { - team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 256; - } LowerTriLvlSchedTP1SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); - Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); + if ( team_size == -1 ) + Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , Kokkos::AUTO ), tstf); + else + Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); } /* // TP2 algorithm has issues with some offset-ordinal combo to be addressed @@ -643,12 +643,12 @@ void upper_tri_solve( TriSolveHandle & thandle, const RowMapType row_map, const typedef Kokkos::TeamPolicy policy_type; int team_size = thandle.get_team_size(); - if ( team_size == -1 ) { - team_size = std::is_same< typename Kokkos::DefaultExecutionSpace::memory_space, Kokkos::HostSpace >::value ? 1 : 256; - } UpperTriLvlSchedTP1SolverFunctor tstf(row_map, entries, values, lhs, rhs, nodes_grouped_by_level, node_count); - Kokkos::parallel_for("parfor_l_team", policy_type( lvl_nodes , team_size ), tstf); + if ( team_size == -1 ) + Kokkos::parallel_for("parfor_u_team", policy_type( lvl_nodes , Kokkos::AUTO ), tstf); + else + Kokkos::parallel_for("parfor_u_team", policy_type( lvl_nodes , team_size ), tstf); } /* // TP2 algorithm has issues with some offset-ordinal combo to be addressed From 094da30c9ad17ae96053a981d77f24d83bd7af97 Mon Sep 17 00:00:00 2001 From: Nathan Ellingwood Date: Mon, 24 Jun 2019 15:30:08 -0600 Subject: [PATCH 190/190] Adding Changelog for Release 2.9.00 Part of Kokkos C++ Performance Portability Programming EcoSystem 2.9 --- CHANGELOG.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d6255e623b..3a64e0183e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,22 @@ # Change Log +## [2.9.00](https://github.com/kokkos/kokkos-kernels/tree/2.9.00) (2019-06-24) +[Full Changelog](https://github.com/kokkos/kokkos-kernels/compare/2.8.00...2.9.00) + +**Implemented enhancements:** + +- KokkosBatched: Add specialization for float2, float4 and double4 [\#427](https://github.com/kokkos/kokkos-kernels/pull/427) +- KokkosBatched: Reduce VectorLength (16 to 8) [\#432](https://github.com/kokkos/kokkos-kernels/pull/432) +- KokkosBatched: Remove experimental name space for batched blas [\#371](https://github.com/kokkos/kokkos-kernels/issues/371) +- Capability: Initial sparse triangular solve capability [\#435](https://github.com/kokkos/kokkos-kernels/pull/435) +- Capability: Add support for MAGMA GESV TPL [\#409](https://github.com/kokkos/kokkos-kernels/pull/409) +- cuBLAS: Add CudaUVMSpace specializations for GEMM [\#397](https://github.com/kokkos/kokkos-kernels/issues/397) + +**Fixed bugs:** + +- Deprecated Code Fixes [\#411](https://github.com/kokkos/kokkos-kernels/issues/411) +- BuildSystem: Compilation error on rzansel [\#401](https://github.com/kokkos/kokkos-kernels/issues/401) + ## [2.8.00](https://github.com/kokkos/kokkos-kernels/tree/2.8.00) (2019-02-05) [Full Changelog](https://github.com/kokkos/kokkos-kernels/compare/2.7.24...2.8.00)