Execution Methods#

Execution methods are used to run the Solver function as defined by user with cuSolverDx operators.

Note

Right now, cuSolverDx supports only execution on CUDA thread block level (block execution).

Block Execute Methods#

The block execution methods are available if the descriptor has been constructed using the Block Operator and is_complete_solver_execution Trait is true. All threads within a block must collectively participate in a block execution method; otherwise, the behavior is undefined.

execute(...) runs the calculations defined by the Solver descriptor, and its arguments vary depending on the descriptor’s function.

using Solver = decltype(cusolverdx::Size<...>() + ...);

// function::potrf and getrf_no_pivot
//
// with compile-time lda
void Solver::execute(typename Solver::a_data_type* A, typename Solver::status_type* status);
// with runtime lda
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::status_type* status);


// function::getrf_partial_pivot
//
// with compile-time lda
void Solver::execute(typename Solver::a_data_type* A, int* ipiv,
                     typename Solver::status_type* status);
// with runtime lda
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::ipiv_data_type* ipiv,
                     typename Solver::status_type* status);

// function::potrs and getrs_no_pivot
//
// with compile-time lda and ldb
void Solver::execute(const typename Solver::a_data_type* A, typename Solver::b_data_type* B);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B);
void Solver::execute(const typename Solver::a_data_type* A,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);

// function::getrs_partial_pivot
//
// with compile-time lda and ldb
void Solver::execute(const typename Solver::a_data_type* A, const int* ipiv,
                     typename Solver::b_data_type* B);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const int* ipiv,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const int* ipiv,
                     typename Solver::b_data_type* B);
void Solver::execute(const typename Solver::a_data_type* A,
                     const int* ipiv,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);

// function::posv and gesv_no_pivot
//
// with compile-time lda and ldb
void Solver::execute(typename Solver::a_data_type* A, typename Solver::b_data_type* B,
                     typename Solver::status_type* status);
// with runtime/compile-time leading dimensions
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb,
                     typename Solver::status_type* status);
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B,
                     typename Solver::status_type* status);
void Solver::execute(typename Solver::a_data_type* A,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb,
                     typename Solver::status_type* status);

// function::gesv_partial_pivot
//
// with compile-time lda and ldb
void Solver::execute(typename Solver::a_data_type* A, int* ipiv,
                     typename Solver::b_data_type* B, typename Solver::status_type* status);
// with runtime/compile-time leading dimensions
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     int* ipiv,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb,
                     typename Solver::status_type* status);
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     int* ipiv,
                     typename Solver::b_data_type* B,
                     typename Solver::status_type* status);
void Solver::execute(typename Solver::a_data_type* A,
                     int* ipiv,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb,
                     typename Solver::status_type* status);


// function::geqrf
//
// with compile-time lda
void Solver::execute(typename Solver::a_data_type* A, typename Solver::a_data_type* tau);
// with runtime lda
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::a_data_type* tau);

// function::gelqrf
//
// with compile-time lda
void Solver::execute(typename Solver::a_data_type* A, typename Solver::a_data_type* tau);
// with runtime lda
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::a_data_type* tau);

// function::unmqr
//
// with compile-time lda
void Solver::execute(const typename Solver::a_data_type* A,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C, const unsigned int runtime_ldc);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C);
void Solver::execute(const typename Solver::a_data_type* A,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C, const unsigned int runtime_ldc);

// function::unmlq
//
// with compile-time lda
void Solver::execute(const typename Solver::a_data_type* A,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C, const unsigned int runtime_ldc);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C);
void Solver::execute(const typename Solver::a_data_type* A,
                     const typename Solver::a_data_type* tau,
                     typename Solver::b_data_type* C, const unsigned int runtime_ldc);

// function::gels
//
// with compile-time lda and ldb
void Solver::execute(const typename Solver::a_data_type* A, typename Solver::b_data_type* B);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B);
void Solver::execute(const typename Solver::a_data_type* A,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);

// function::trsm
//
// with compile-time lda and ldb
void Solver::execute(const typename Solver::a_data_type* A, typename Solver::b_data_type* B);
// with runtime/compile-time leading dimensions
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);
void Solver::execute(const typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::b_data_type* B);
void Solver::execute(const typename Solver::a_data_type* A,
                     typename Solver::b_data_type* B, const unsigned int runtime_ldb);