| Nbatchlas | |
| Nbackend | |
| Ndetail | |
| CSyr2kTriangularTilesKernel | |
| CSyrkGramTilesKernel | |
| CSyrkTriangularTilesKernel | |
| CTrmmTriangularTilesKernel | |
| Ncoverage | |
| CShape | |
| Ndetail | |
| Ccontainer_elem | |
| Ccontainer_elem< Matrix< T, F > > | |
| Ccontainer_elem< MatrixView< T, F > > | |
| Ccontainer_elem< P< T > > | |
| Ccontainer_elem< Span< T > > | |
| Ccontainer_elem< std::complex< T > > | |
| Ccontainer_elem< UnifiedVector< T > > | |
| Ccontainer_elem< Vector< T > > | |
| Ccontainer_elem< VectorView< T > > | |
| Cdense_scalar | |
| Cdense_scalar< Matrix< T, MatrixFormat::Dense > > | |
| Cdense_scalar< MatrixView< T, MatrixFormat::Dense > > | |
| Cexception_bridge | Derives from StdBase and, virtually, from batchlas::exception |
| Ndevice | |
| Ndetail | |
| Ngeneric | |
| CGemvTransposeWorkspace | |
| CSymvTransposeWorkspace | |
| Nsubgroup | |
| CRegisterMatrixAccumTile | |
| CComplexRank2kAccumTile | |
| CRegisterMatrixWorkspace | |
| CComplexRank2kWorkspace | |
| CComplexRank2kInKernelWorkspace | |
| COptimizedGemmWorkspace | |
| CGemmWorkspace | |
| C[union].__unnamed0__ | |
| CPacketArray | |
| CRegisterMatrixThreadTileValues | |
| CTriangularTransformTag | |
| CSymmetricTransformTag | |
| CSymmetricRankTransformTag | |
| CDeviceBlasLaunchInfo | Host-side description of a launch, for the *_workspace_elements queries |
| CMatrixVectorOperand | Operands of a matrix-vector operation: \( y := \alpha\,\mathrm{op}(A)\,x + \beta\,y \) |
| CMatrixMatrixOperand | Operands of a matrix-matrix operation: \( C := \alpha\,(\ldots B \ldots) + \beta\,C \) |
| CRankKOperand | Operands of a rank-k update: \( C := \alpha\,\mathrm{op}(A)\,\mathrm{op}(A)^{T|H} + \beta\,C \) |
| CRank1UpdateOperand | Operands of a rank-1 update: \( A := A + \alpha\,x\,y^{T} \) (conjugations per call) |
| CMatrixVectorTransform | Runtime transpose mode of a matrix-vector operation |
| CMatrixVectorTransformTag | Compile-time transpose mode of a matrix-vector operation |
| CGeneralMatrixTransform | Runtime transpose modes of a general matrix-matrix product |
| CGeneralMatrixTransformTag | Compile-time transpose modes of a general matrix-matrix product |
| CTriangularTransform | Mode of a triangular product (trmv, trmm) |
| CSymmetricTransform | Mode of a symmetric or Hermitian product (symv, hemv, symm) |
| COuterProductTransform | Conjugation mode of a rank-1 update (ger, geru, gerc) |
| COuterProductTransformTag | Compile-time conjugation mode of a rank-1 update |
| CSymmetricRank2kTransform | Mode of a symmetric or Hermitian rank-2k update (syr2k, her2k) |
| CSymmetricRankKTransform | Mode of a symmetric or Hermitian rank-k update (syrk, herk) |
| Ngeqrf_native | |
| CGeqrfGlobalTile | |
| CGeqrfPanelRegPlan | |
| CGeqrfPanelRegPlan< double > | |
| CGeqrfPanelRegPlan< float > | |
| CGeqrfPanelRegPlan< sycl_device::Cx< double > > | |
| CGeqrfPanelRegPlan< sycl_device::Cx< float > > | |
| CGeqrfTinyRegs | |
| CGeqrfTinyRegs< double > | |
| CGeqrfTinyRegs< float > | |
| CGeqrfTinyRegs< sycl_device::Cx< double > > | |
| CGeqrfTinyRegs< sycl_device::Cx< float > > | |
| CLarfgScalars | |
| CRealOf | |
| CRealOf< Cx< R > > | |
| Ngetrf_native | |
| CRealOf | |
| CRealOf< Cx< R > > | |
| CLuGlobalTile | |
| Ninternal | |
| Cbtrd_givens_ops | |
| Cbtrd_givens_ops< T, false > | |
| Cbtrd_givens_ops< T, true > | |
| CConstStridedView | |
| CSb2stHhRefl | |
| CStridedView | |
| Nlinalg | |
| CMatmulOptions | Options for matmul(). Deliberately has no beta: C is freshly allocated |
| CEigh | Result of eigh() |
| CSvd | Result of svd() |
| CLu | Result of lu() |
| Nops | |
| Ngemm | |
| CDirect | Gemm_direct: one work-item per element, any form; max_wg >= 64 |
| CTiled | Gemm_tiled: 16x16 shared-memory tile, any form; max_wg >= 256 |
| CSmall | Gemm_small: several matrices per work-group; real, see small_fits |
| CReg | Gemm_reg, float only: m x n x k macro tile with k unroll u; must name a reg_configs entry that instantiates the call's transpose form, and max_wg must cover its threads() |
| CWide | Gemm_wide, every scalar: 16-byte-granule m x n x k tiles; must name a wide_configs entry that instantiates the call's form, and max_wg must cover its threads() |
| CVendor | Backend::gemm_vendor; needs the level-3 library |
| CForms | Transpose forms an instantiation exists for, after the real-scalar C->T fold |
| CRegCfg | One compiled register config: tr/tc thread tile, stages, the forms instantiated, and whether NN takes the unpredicated leg when the layout allows (derived per call, never a gate) |
| CWideCfg | One compiled wide config |
| Ngemv | |
| CCta | Sycl_gemv::gemv_native_cta, sub-group per output; Trans/ConjTrans |
| CDirect | Sycl_gemv::gemv_native_direct, item per output; every device |
| CVendor | Backend::gemv_vendor; any shape, needs the library |
| Ngeqrf | |
| CBlocked | Geqrf_blocked_dispatch + the public gemm, any m >= n |
| CCta | Geqrf_cta_dispatch: the whole panel in SLM (geqrf_cta_fits) |
| Coverloaded | Std::visit over a choice with one lambda per family |
| CTiny | Geqrf_tiny_dispatch: square, registers, n <= the tiny ceiling |
| CVendor | Backend::geqrf_vendor; needs the factorization library |
| Ngesv | |
| CTiny | Gesv_tiny_dispatch: fused LU factor + solve (buckets derived) |
| CBlocked | Public getrf + public getrs; any homogeneous batch |
| Ngesvd | |
| CJacobi | Gesvdj_cta: one-sided Jacobi, max(m, n) <= 64, not Hermitian |
| CCta | Gesvd_cta: normal equations + syev_cta, max(m, n) <= 32, not thin |
| CBlocked | Gesvd_blocked: bidiagonalisation + bdsdc, or syev_blocked (Lower) |
| CVendor | Backend::gesvd_vendor; needs the solver library |
| Ngetrf | |
| CTiny | Getrf_tiny_dispatch: register-resident, n <= 32 (cdouble 16) |
| CCta | Getrf_cta_dispatch: SLM-resident panel, n <= the SLM ceiling |
| CBlocked | Getrf_blocked_dispatch + the public gemm and trsm |
| CVendor | Backend::getrf_vendor (cuBLAS / rocSOLVER / LAPACKE) |
| Ngetri | |
| CBlocked | Getri_blocked_dispatch: P into C + two public trsm; GPU, square |
| CVendor | Backend::getri_vendor; also CPU, NETLIB, heterogeneous batches |
| Ngetrs | |
| CCta | Getrs_fused_dispatch: permute + both solves; B fits in SLM |
| CBlocked | Getrs_blocked_dispatch: laswp + two public trsm |
| CVendor | Backend::getrs_vendor; also takes non-conforming pairs |
| Norgqr | |
| CBlocked | Orgqr_blocked_dispatch: identity + the public ormqr; GPU, n <= m |
| CVendor | Backend::orgqr_vendor; any shape (n > m, CPU, heterogeneous) |
| Normqr | |
| CBlocked | Ormqr_blocked (larft + level-3 WY updates); GPU, no complex Trans |
| CVendor | Backend::ormqr_vendor; no complex Trans either |
| Nposv | |
| CTiny | Posv_tiny_dispatch: fused factor + solve, small n and nrhs |
| CCta | Public potrf + potrs_fused_dispatch; B fits in SLM |
| CBlocked | Public potrf + two public trsm; any homogeneous batch |
| Npotrf | |
| CTiny | Potrf_tiny_dispatch: registers; n <= potrf_tiny_max_n, max_wg >= 64 |
| CCta | Potrf_cta_dispatch: whole matrix in SLM; n <= the CTA SLM ceiling |
| CLpanel | Potrf_lpanel_dispatch: SLM-resident panels; Lower only, n <= the LPanel SLM ceiling for panel |
| CBlocked | Potrf_blocked_dispatch + gemm/trsm, Lower; nb/W: PotrfBlockedConst + env |
| CVendor | Backend::potrf_vendor; needs the solver library |
| Nspmm | |
| CDirect | Sycl_spmm::spmm_native_csr: CSR only, no GPU gate (native_cpu too) |
| CVendor | Backend::spmm_vendor (cuSPARSE, rocSPARSE, netlib) less known-defect shapes |
| Nsyev | |
| CCta | Syev_cta: sytrd + steqr_cta, n <= 32 |
| CCtaFused | Syev_cta_fused: one kernel, n <= 32 |
| CJacobi | Syev_jacobi_cta, n <= 32 |
| CBlocked | Syev_blocked: sytrd_blocked + stedc, any n |
| CTwoStage | Syev_two_stage: sy2sb + sb2st + stedc, any n |
| CVendor | Backend::syev_vendor; needs the solver library |
| Nsymm | |
| CExpand | Expand_mirrored into scratch + the public gemm; scratch must fit |
| CVendor | Backend::symm_vendor (cublas?symm / cblas_?symm loop) |
| Nsyr2k | |
| CTriangular | Syr2k_triangular_tiles<float>, CUDA GPU; real ConjTrans runs as Trans |
| CVendor | Backend::syr2k_vendor (per-item ?syr2k loop) |
| Nsyrk | |
| CGram | Syrk_gram_tiles: one tile covers C; n <= 128, tile SLM fits |
| CTriangular | Syrk_triangular_tiles<float>: 128-wide tiles of one half |
| CVendor | Backend::syrk_vendor (per-item ?syrk loop) |
| Ntrmm | |
| CTriangular | Trmm_triangular_tiles: Side::Left; tile grid <= 65535 |
| CExpand | Expand_triangular + the public gemm; scratch must fit |
| CVendor | Backend::trmm_vendor (cublas?trmm loop) |
| Ntrsm | |
| CCta | Trsm_native_v1_dispatch, order <= 32 |
| CSgLeft | Trsm_native_sg_left_dispatch: Left, order <= 32, sg 32 |
| CBlocked | Trsm_native_blocked + the public gemm, any order |
| CVendor | Backend::trsm_vendor; needs the level-3 library |
| Nportable | |
| Ndetail | |
| Cis_std_complex | |
| Cis_std_complex< std::complex< R > > | |
| Csycl_vec | |
| Csycl_vec< sycl::vec< R, N > > | |
| Crebind_op | |
| Crebind_op< OpT< V >, R > | |
| Nselect | |
| Ndetail | |
| CNativeFacts | The coverage row's native_route_existed / native_route_supported (tri-state, -1 unknown) |
| CDevice | The device facts a can_run predicate and the table lookup read (§5.1) |
| CFamilyName | A string literal as a template argument: the name of a NoFields family |
| CNoFields | Base of a family with no knobs: struct Cta : NoFields<"cta"> {}; |
| Coverloaded | Std::visit over a choice with one lambda per family |
| CRules | What an op adds to the generic walk: its last-resort order |
| CKeyField | One field of a lookup key, value as text; a Key lists the fields an op's table keys name |
| CTableKey | One entry of a table's # keys: line |
| CTableEntry | One ranked candidate of a row: its spelling and milliseconds per call for the whole batch |
| CTableRow | One measured (or transcribed) shape and every candidate ranked there, fastest first |
| CTable | One dtype's table: a tuned/<op>.<device>.txt file holds one per dtype |
| CEmbeddedTable | A tuned/*.txt file compiled into the library: its basename and text |
| CStrictPin | Tag for a strict ScopedPin: a class word ("native", "vendor") that cannot serve the shape throws std::invalid_argument instead of falling back to auto |
| CScopedPin | RAII pin for op: wins over BATCHLAS_<OP>_ROUTE on this thread; nests, restoring the outer pin on exit |
| CTraceScope | Prints the last choose() decision for op under BATCHLAS_SELECT_TRACE=1, indents nested scopes, and records the coverage row |
| COpSpec | What an op's choice.hh declares once: its name, the library its Vendor family calls (one gate for can_run, the launch arm and the NoRouteError), and its last-resort order |
| CNativeFacts | The coverage row's native_route_existed / native_route_supported (tri-state, -1 unknown) |
| Nsycl_gemm | |
| Nwide_scalar | |
| CTile | |
| CGemm128x128Body | |
| CGemmRegister128x128Kernel | |
| CGemmRegister64x64K16WideKernel | |
| CGemmRegisterTiledKernel | |
| CGemmTiledGeneralKernel | |
| CGemmWideTransposedKernel | |
| CLinearEpilogue | |
| COperandAccessor | |
| CRegisterTilePolicy | |
| CRegTile | |
| CWideTile | |
| Nsycl_gemm_small | |
| CGemmSmallBatchedKernel | |
| CGemmSmallTiledKernel | |
| Nsycl_trsm | |
| CCanonical | |
| Nverify | |
| CSlack | A per-site factor on a kind's bound, in either direction |
| Capi_misuse | A well-formed call arrived in a state, order or thread where it is not valid |
| CBackendMatrixHandle | Backend-library descriptor for a matrix (cuSPARSE / rocSPARSE handles); defined in src/ |
| Cbase_type | Real type underlying a scalar: T itself for a real T, R for std::complex<R> |
| Cbase_type< std::complex< T > > | Specialisation that strips std::complex |
| CBatchedMatrixDecomposition | Result of compute_batched_matrix_decomposition() |
| CBatchedNdRangeSizes | Result of compute_batched_nd_range_sizes() |
| CBatchSize | Number of batch items, as a distinct type |
| CBumpAllocator | Linear (bump) sub-allocator over a caller-supplied workspace buffer |
| Cconvergence_error | An iterative kernel did not converge, or a factorisation broke down on the data |
| Ccta_rotation | |
| CDevice | A handle to one SYCL device: its type and its index among devices of that type |
| Cdevice_error | The device or its vendor runtime failed |
| CDiagnosticsSettings | Tracing, dumping, profiling and the opt-in checks |
| CDumpBandR1Settings | The BATCHLAS_DUMP_BANDR1_* band-reduction dump family |
| CEnvValue | A raw captured environment value, shaped like the std::getenv call it replaces |
| Cerror | Base of the runtime arm: the call failed for a reason that is not a bad argument |
| CEvent | Completion handle of enqueued work, returned by every entry point |
| Cexception | Empty tag base of every BatchLAS exception |
| CGemmOptions | Options for gemm(): \(C := \alpha\,\mathrm{op}(A)\,\mathrm{op}(B) + \beta C\) |
| CGemvOptions | Options for gemv(): \(y := \alpha\,\mathrm{op}(A)\,x + \beta y\) |
| CGeometrySettings | Launch geometry, block widths, iteration counts and tuning thresholds |
| CTuneSettings | The runtime overrides of include/batchlas/tuning_params.hh (BATCHLAS_TUNE_*) |
| CGesvdjParams | Parameters for the one-sided Jacobi SVD (gesvdj_cta) |
| CGesvdOptions | Options for gesvd(): \(A = U\Sigma V^H\) |
| CGetrsOptions | Options for getrs(): solve \(\mathrm{op}(A)X = B\) with getrf's factors |
| CHemmOptions | Options for hemm(): as SymmOptions, with A Hermitian |
| CHer2kOptions | Options for her2k(): \(C := \alpha\,\mathrm{op}(A)\,\mathrm{op}(B)^H + \bar\alpha\,\mathrm{op}(B)\,\mathrm{op}(A)^H + \beta C\) |
| CHerkOptions | Options for herk(): \(C := \alpha\,\mathrm{op}(A)\,\mathrm{op}(A)^H + \beta C\) |
| CILUKParams | Parameters of an incomplete LU factorization with level-of-fill k, ILU(k) |
| CILUKPreconditioner | Owning ILU(k) factor of a batch of CSR matrices sharing one pattern |
| CILUKView | Non-owning description of a factored ILU(k) preconditioner |
| CInc | Element distance between consecutive vector entries, as a distinct type |
| Cinternal_error | BatchLAS is internally inconsistent |
| Cinvalid_argument | The call violates the API contract |
| Cis_std_array | True for std::array<T, N>, false otherwise |
| Cis_std_array< std::array< T, N > > | Specialisation for std::array<T, N> |
| Cis_std_complex | True for std::complex<R>, false otherwise |
| Cis_std_complex< std::complex< T > > | Specialisation for std::complex<R> |
| CJacobiParams | Parameters for syev_jacobi_cta() (cyclic two-sided Jacobi) |
| CKernelMatrixView | Trivially copyable view of a MatrixView for use inside a SYCL kernel |
| CLanczosParams | Parameters for lanczos() |
| CLd | Leading dimension (column pitch), as a distinct type (0 = packed) |
| CMatrix | Owning batch of batch_size() matrices of equal (capacity) shape |
| CMatrixView | Non-owning view of a batch of matrices: the argument type of every entry point |
| CNonZeros | Non-zero count (per-item capacity) of a CSR matrix, as a distinct type |
| CNoRouteError | |
| COrmqrOptions | Options for ormqr(): apply geqrf()'s Q, \(C := \mathrm{op}(Q)C\) (Left) or \(C\,\mathrm{op}(Q)\) (Right) |
| COrthoAgainstOptions | Options for the option-struct ortho() against an external basis M |
| COrthoOptions | Options for the option-struct ortho(); fields as the positional arguments |
| Cout_of_range | An index is outside its container |
| CPotrfOptions | Options for potrf(): Cholesky \(A = LL^H\) (Lower) or \(U^HU\) (Upper) |
| CQSharedCache | |
| CQSharedCache< T, P, LDQ, false, LocalAcc > | |
| CQSharedCache< T, P, LDQ, true, LocalAcc > | |
| CQueue | Where BatchLAS work runs: a device, a backend, an ordered SYCL queue and a workspace arena |
| CRoutingSettings | The route pins: BATCHLAS_<OP>_ROUTE, one raw string per op that selects a kernel |
| CScopedEnvVar | Sets (or unsets) an environment variable for a scope and restores it on exit |
| CSelectionSettings | Which kernel or algorithm runs, for the knobs outside the route pins |
| CSettings | Everything BatchLAS reads from its environment, in one value |
| CSlice | A half-open index range [start, end) along one dimension |
| CSliceEnd | Marker for "to the end" in a Slice: Slice(k, SliceEnd{}) selects [k, dim) |
| CSpan | Non-owning view of size() contiguous elements of type T |
| CStebzParams | Parameters for stebz() (bisection on a symmetric tridiagonal matrix) |
| CStedcLevelPlan | |
| CStedcParams | Parameters for stedc() |
| CSteinParams | Parameters for stein() (inverse iteration on a symmetric tridiagonal) |
| CSteqrParams | Parameters for steqr() and steqr_cta(), and for stedc()'s leaf solves |
| CStride | Element distance between consecutive batch items, as a distinct type (0 = packed) |
| CSyevOptions | Options for syev(): symmetric/Hermitian eigendecomposition |
| CSyevxInstrumentation | Optional per-iteration convergence histories recorded by the iterative syevx paths |
| CSyevxParams | Options for syevx(): algorithm family, convergence controls, preconditioning and which part of the spectrum to compute |
| CSyevxResolvedRange | Resolved, algorithm-independent description of the caller's request |
| CSymmOptions | Options for symm(): \(C := \alpha A B + \beta C\) (Left) or \(\alpha B A + \beta C\) (Right), A symmetric |
| CSyr2kOptions | Options for syr2k(): \(C := \alpha(\mathrm{op}(A)\,\mathrm{op}(B)^T + \mathrm{op}(B)\,\mathrm{op}(A)^T) + \beta C\) |
| CSyrkOptions | Options for syrk(): \(C := \alpha\,\mathrm{op}(A)\,\mathrm{op}(A)^T + \beta C\) |
| CSytrdBandReductionParams | Sweep schedule for sytrd_band_reduction() (successive band reduction) |
| CTrmmOptions | Options for trmm(): \(C := \alpha\,\mathrm{op}(A)\,B\) (Left) or \(\alpha B\,\mathrm{op}(A)\) (Right). No beta |
| CTrsmOptions | Options for trsm(): solve \(\mathrm{op}(A)X = \alpha B\) (Left) or \(X\,\mathrm{op}(A) = \alpha B\) (Right) |
| CUnifiedVector | Owning, growable array of T in USM shared memory (sycl::malloc_shared) |
| CUnsafeSettings | The overrides that remove a guarantee: setting one can make a correct program crash, hang or silently compute wrong numbers |
| Cunsupported | No kernel, backend or vendor entry point in this build on this device serves the request |
| CVector | Owning batch of batch_size() vectors of length size() in USM shared memory |
| CVectorView | Non-owning view of a batch of strided vectors: the vector argument type of the entry points |
| CWorkgroupAdapter | |
| Cworkspace_error | The scratch the operation was handed is too small, or the allocator ran out of it |
| CWorkspaceLease | A borrow of scratch memory from a Queue's workspace arena, returned to the arena when the handle goes out of scope |
| Nminiacc | |
| CConfig | Run-wide settings parsed from the command line |
| CSampleRow | |
| CMetricSummary | |
| CResult | |
| CState | Per-case context handed to a benchmark: its arguments, the run settings, and the sample sink |
| CBenchmark | A registered case: name, function, and its argument lists (Args, ArgRange, ArgsProduct) |
| CSummaryMetricColumns | |
| CCliOptions | |
1.18.0
