Execution Methods

Execution methods run the solver function defined by cuSolverDx operators. They are available when the descriptor has been constructed using either Thread Operator or Block Operator, and is_complete_solver_execution Trait is true.

The execute(...) method performs the calculations defined by the Solver descriptor. Its arguments vary depending on the descriptor’s function, but the API is identical between thread and block execution.

 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::modified_lu
 //
 // with compile-time ldq
 void Solver::execute(typename Solver::a_data_type* Q, typename Solver::a_data_type* S);
 // with runtime ldq
 void Solver::execute(typename Solver::a_data_type* Q, const unsigned int runtime_ldq,
                      typename Solver::a_data_type* S);

 // 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::gtsv_no_pivot
 //
 // with compile-time ldb
 void Solver::execute(const typename Solver::a_data_type* dl, const typename Solver::a_data_type* d,
                      const typename Solver::a_data_type* du, typename Solver::b_data_type* B,
                      typename Solver::status_type* status);
 // with runtime leading dimension of `B`
 void Solver::execute(const typename Solver::a_data_type* dl, const typename Solver::a_data_type* d,
                      const typename Solver::a_data_type* du, 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::gelqf
 //
 // 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::ungqr
 //
 // with compile-time lda
 void Solver::execute(typename Solver::a_data_type* A, const typename Solver::a_data_type* tau);
 // with runtime lda
 void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                      const typename Solver::a_data_type* tau);

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

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


// function::htev
//
// Compute eigenvalues only
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::status_type* info);

// Compute eigenvalues, and optionally the eigenvectors
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::a_data_type* V, typename Solver::status_type* info);

// Compute eigenvalues and eigenvectors with leading dimension of `V`
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::a_data_type* V, const unsigned int runtime_ldv,
                     typename Solver::status_type* info);

// function::heev
//
// Compute eigenvalues, and optionally the eigenvectors
void Solver::execute(typename Solver::a_data_type* A, typename Solver::a_precision* lambda,
                     typename Solver::a_data_type* workspace, typename Solver::status_type* info);

// with runtime leading dimension of `V`
void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                     typename Solver::a_precision* lambda,
                     typename Solver::a_data_type* workspace, typename Solver::status_type* info);

// function::bdsvd
//
// Compute singular values only
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::status_type* info);

// Compute singular values, and optionally the left and/or right singular vectors
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::a_data_type* U, typename Solver::a_data_type* VT,
                     typename Solver::status_type* info);
// Compute singular values, and optionally the left and/or right singular vectors
// with runtime leading dimension of `U` and `VT`
void Solver::execute(typename Solver::a_data_type* d, typename Solver::a_data_type* e,
                     typename Solver::a_data_type* U, const unsigned int ldu,
                     typename Solver::a_data_type* VT, const unsigned int ldvt,
                     typename Solver::status_type* info);

 // function::gesvd
 //
 // Compute singular values only
 void Solver::execute(typename Solver::a_data_type* A, typename Solver::a_precision* sigma,
                      typename Solver::a_data_type* workspace, typename Solver::status_type* info);

 // Compute singular values only with runtime leading dimension of `A`
 void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                      typename Solver::a_precision* sigma,
                      typename Solver::a_data_type* workspace, typename Solver::status_type* info);

 // Compute singular values, and optionally the left and/or right singular vectors
 void Solver::execute(typename Solver::a_data_type* A, typename Solver::a_precision* sigma,
                      typename Solver::a_data_type* U, typename Solver::a_data_type* VT,
                      typename Solver::a_data_type* workspace, typename Solver::status_type* info);

 // Compute singular values, and optionally the left and/or right singular vectors
 // with runtime leading dimension of `U` and `VT`
 void Solver::execute(typename Solver::a_data_type* A, const unsigned int runtime_lda,
                    typename Solver::a_precision* sigma,
                    typename Solver::a_data_type* U, const unsigned int ldu,
                    typename Solver::a_data_type* VT, const unsigned int ldvt,
                    typename Solver::a_data_type* workspace, typename Solver::status_type* info);