Namespace muda

Namespaces

Type	Name
namespace	config
namespace	details
namespace	distance
namespace	eigen
namespace	lbvh
namespace	spatial_hash

Classes

Type	Name
class	BSRMatrixViewT <IsConst, typename Ty, N>
class	Buffer2DViewT <IsConst, typename T>
class	Buffer3DViewT <IsConst, typename T>
class	BufferLaunch
class	BufferViewT <IsConst, typename T>
class	CFieldEntryView <typename T, Layout, M, N>
class	CFieldEntryViewer <typename T, Layout, M, N>
class	CMatrixMapInfo <typename T, M, N>
class	COOMatrixViewT <IsConst, typename Ty>
class	COOVectorViewBase <IsConst, typename T>
class	ClosureId
class	ComputeGraph
class	ComputeGraphBuilder
class	ComputeGraphCaptureNode
class	ComputeGraphClosure
class	ComputeGraphDependency
class	ComputeGraphGraphvizOptions
class	ComputeGraphNode <typename NodeT, Type>
class	ComputeGraphNodeBase
class	ComputeGraphVar <typename T>
class	ComputeGraphVar <typename T>
class	ComputeGraphVar <typename T>
class	ComputeGraphVar <typename T>
class	ComputeGraphVar <typename T>
class	ComputeGraphVar <typename T>
class	ComputeGraphVarBase
class	ComputeGraphVarManager
class	CubWrapper <typename Derive>
class	Debug
struct	Default
class	Dense1DT <IsConst, typename T>
class	Dense2DBase <IsConst, typename T>
class	Dense3DBase <IsConst, typename T>
class	DenseMatrixViewT <IsConst, typename Ty>
class	DenseMatrixViewerT <IsConst, typename T>
class	DenseVectorViewT <IsConst, typename T>
class	DenseVectorViewerT <IsConst, typename T>
class	DenseViewerT <IsConst, typename T>
class	DeviceBCOOMatrix <typename T, N>
class	DeviceBCOOMatrix <typename T, N>
class	DeviceBCOOVector <typename T, N>
class	DeviceBCOOVector <typename T, N>
class	DeviceBSRMatrix <typename Ty, N>
class	DeviceBuffer <typename T> A `std::vector` like wrapper of cuda device memory, allows user to:
class	DeviceBuffer2D <typename T>
class	DeviceBuffer3D <typename T>
class	DeviceDenseMatrix <typename Ty>
class	DeviceDenseVector <typename T>
class	DeviceDoubletVector <typename T, N>
class	DeviceHistogram
class	DeviceMergeSort
class	DevicePartition
class	DeviceRadixSort
class	DeviceReduce
class	DeviceRunLengthEncode
class	DeviceScan
class	DeviceSegmentedRadixSort
class	DeviceSegmentedReduce
class	DeviceSegmentedSort
class	DeviceSelect
class	DeviceSpmv
class	DeviceTripletMatrix <typename T, N>
class	DeviceVar <typename T>
class	DeviceVector <typename T>
class	DoubletVectorViewT <IsConst, typename T, N>
class	DoubletVectorViewT <IsConst, typename T, N>
class	DoubletVectorViewerT <IsConst, typename T, N>
class	Empty
class	Event RAII wrapper for cudaEvent.
class	EventRecordNode
class	EventWaitNode
class	Extent2D
class	Extent3D
class	Field
class	FieldBuildOptions
class	FieldBuilder <Layout>
class	FieldEntry <typename T, Layout, M, N>
class	FieldEntryBase
class	FieldEntryBaseData
class	FieldEntryCore
class	FieldEntryLaunch
class	FieldEntryLayoutInfo
class	FieldEntryView <typename T, Layout, M, N>
class	FieldEntryViewBase <IsConst, typename T, Layout, M, N>
class	FieldEntryViewCore <IsConst, typename T, Layout, M, N>
class	FieldEntryViewer <typename T, Layout, M, N>
class	FieldEntryViewerBase <IsConst, typename T, Layout, M, N>
class	FieldEntryViewerCore <IsConst, typename T, Layout, M, N>
class	Flags <typename BitType>
class	Graph
class	GraphExec
class	GraphLaunch
class	GraphNode
class	GraphViewer
class	HostCall
class	HostDeviceConfig <typename T>
class	HostDeviceConfigView <typename T>
class	HostNode
class	HostNodeParms <typename T>
class	HostVector <typename T>
class	IdWithType <typename T>
class	Kernel <typename F>
class	KernelLabel
class	KernelNode
class	KernelNodeParms <typename U>
class	Launch A wrapper of raw cuda kernel launch in muda style , removing the`<<<>>>` usage, for better intellisense support.
class	LaunchBase <typename T>
class	LaunchCore
class	LinearSystemAlgorithm
class	LinearSystemContext
class	LinearSystemContextCreateInfo
class	LinearSystemHandles
class	LinearSystemSolveReorder
class	LinearSystemSolveTolerance
class	LogProxy
class	Logger
class	LoggerDataContainer
class	LoggerMetaData
class	LoggerViewer
class	MatrixFormatConverter
class	MatrixMapInfo <typename T, M, N> For MapMatrix e.g. Eigen::Map< ... >
class	MemcpyNode
class	Memory
class	MemsetNode
class	NDReshaper
class	NodeId
class	NodeParms
class	Offset2D
class	Offset3D
class	ParallelFor a frequently used parallel for loop, DynamicBlockDim andGridStrideLoop strategy are provided, and can be switched seamlessly to each other.
class	ParallelForDetails
class	Profile
class	RangeName
class	Stream RAII wrapper for cudaStream.
class	SubField
class	SubFieldImpl <Layout>
class	SubFieldImpl <Layout>
class	SubFieldImpl <Layout>
class	SubFieldImpl <Layout>
class	SubFieldInterface
struct	Tag <typename T>
class	TripletMatrixViewT <IsConst, typename Ty, N>
class	TripletMatrixViewT <IsConst, typename Ty, N>
class	TripletMatrixViewerT <IsConst, typename T, N>
class	VarId
class	VarViewT <IsConst, typename T>
class	ViewBase <IsConst_>
class	ViewerBase <IsConst_>
struct	always_false <typename T>
struct	always_true <typename T>
class	cuda_error <typename T>
class	exception
struct	force_trivial <typename T>
struct	force_trivially_constructible <typename T>
struct	force_trivially_copy_assignable <typename T>
struct	force_trivially_copy_constructible <typename T>
struct	force_trivially_destructible <typename T>
class	invalid_argument
struct	is_cuda_arch
class	logic_error
class	not_implemented
class	out_of_range
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_only_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
struct	read_write_view <typename T>
class	runtime_error

Public Types

Type	Name
typedef TripletMatrixView< T, N >	BCOOMatrixView
typedef CTripletMatrixViewer< T, N >	BCOOMatrixViewer
typedef DoubletVectorView< T, N >	BCOOVectorView
typedef CDoubletVectorViewer< T, N >	BCOOVectorViewer
typedef BSRMatrixViewT< false, Ty, N >	BSRMatrixView
typedef Buffer2DViewT< false, T >	Buffer2DView
typedef Buffer3DViewT< false, T >	Buffer3DView
typedef BufferViewT< false, T >	BufferView
typedef CTripletMatrixView< T, N >	CBCOOMatrixView
typedef CTripletMatrixViewer< T, N >	CBCOOMatrixViewer
typedef CDoubletVectorView< T, N >	CBCOOVectorView
typedef CDoubletVectorViewer< T, N >	CBCOOVectorViewer
typedef BSRMatrixViewT< true, Ty, N >	CBSRMatrixView
typedef Buffer2DViewT< true, T >	CBuffer2DView
typedef Buffer3DViewT< true, T >	CBuffer3DView
typedef BufferViewT< true, T >	CBufferView
typedef COOMatrixViewT< true, Ty >	CCOOMatrixView
typedef CBCOOMatrixViewer< T, 1 >	CCOOMatrixViewer
typedef COOVectorViewBase< true, T >	CCOOVectorView
typedef CBCOOVectorViewer< T, 1 >	CCOOVectorViewer
typedef CSRMatrixViewT< true, Ty >	CCSRMatrixView
typedef DenseViewerT< true, T >	CDense
typedef Dense1DT< true, T >	CDense1D
typedef Dense2DBase< true, T >	CDense2D
typedef Dense3DBase< true, T >	CDense3D
typedef DenseMatrixViewT< true, Ty >	CDenseMatrixView
typedef DenseMatrixViewerT< true, T >	CDenseMatrixViewer
typedef DenseVectorViewT< true, Ty >	CDenseVectorView
typedef DenseVectorViewerT< true, T >	CDenseVectorViewer
typedef DoubletVectorViewT< true, T, N >	CDoubletVectorView
typedef DoubletVectorViewerT< true, T, N >	CDoubletVectorViewer
typedef COOMatrixViewT< false, Ty >	COOMatrixView
typedef BCOOMatrixViewer< T, 1 >	COOMatrixViewer
typedef COOVectorViewBase< false, T >	COOVectorView
typedef BCOOVectorViewer< T, 1 >	COOVectorViewer
typedef CSRMatrixViewT< false, Ty >	CSRMatrixView
typedef BSRMatrixViewT< IsConst, Ty, 1 >	CSRMatrixViewT
typedef TripletMatrixViewT< true, Ty, N >	CTripletMatrixView
typedef TripletMatrixViewerT< true, T, N >	CTripletMatrixViewer
typedef VarViewT< true, T >	CVarView
typedef ComputeGraphNode< EventRecordNode, ComputeGraphNodeType::EventRecordNode >	ComputeGraphEventRecordNode
typedef ComputeGraphNode< EventWaitNode, ComputeGraphNodeType::EventWaitNode >	ComputeGraphEventWaitNode
enum	ComputeGraphFlag
typedef ComputeGraphNode< KernelNode, ComputeGraphNodeType::KernelNode >	ComputeGraphKernelNode
typedef ComputeGraphNode< MemcpyNode, ComputeGraphNodeType::MemcpyNode >	ComputeGraphMemcpyNode
typedef ComputeGraphNode< MemsetNode, ComputeGraphNodeType::MemsetNode >	ComputeGraphMemsetNode
enum uint8_t	ComputeGraphNodeType
enum	ComputeGraphPhase
enum char	ComputeGraphVarUsage
typedef Tag< Default >	DefaultTag
typedef DenseViewerT< false, T >	Dense
typedef Dense1DT< false, T >	Dense1D
typedef Dense2DBase< false, T >	Dense2D
typedef Dense3DBase< false, T >	Dense3D
typedef DenseMatrixViewT< false, Ty >	DenseMatrixView
typedef DenseMatrixViewerT< false, T >	DenseMatrixViewer
typedef DenseVectorViewT< false, Ty >	DenseVectorView
typedef DenseVectorViewerT< false, T >	DenseVectorViewer
typedef DeviceBCOOMatrix< T, 1 >	DeviceCOOMatrix
typedef DeviceBCOOVector< T, 1 >	DeviceCOOVector
typedef DeviceBSRMatrix< T, 1 >	DeviceCSRMatrix
typedef DoubletVectorViewT< false, T, N >	DoubletVectorView
typedef DoubletVectorViewerT< false, T, N >	DoubletVectorViewer
enum	FieldEntryLayout
enum	FieldEntryType
enum	GraphInstantiateFlagBit
typedef IdWithType< int32_t >	I32IdWithType
typedef IdWithType< int64_t >	I64IdWithType
typedef cub::KeyValuePair< Key, Value >	KeyValuePair
enum	LinearSystemReorderMethod
enum uint16_t	LoggerBasicType
typedef void()(void formatter, const void *obj)	LoggerFmtArg
enum uint32_t	ParallelForType
typedef TripletMatrixViewT< false, Ty, N >	TripletMatrixView
typedef TripletMatrixViewerT< false, T, N >	TripletMatrixViewer
typedef IdWithType< uint32_t >	U32IdWithType
typedef IdWithType< uint64_t >	U64IdWithType
typedef VarViewT< false, T >	VarView
typedef std::remove_all_extents_t< std::remove_reference_t< T > >	raw_type_t
typedef typename read_only_view< T >::type	read_only_view_t
typedef typename read_write_view< T >::type	read_write_view_t
typedef tcb::span< T >	span

Public Attributes

Type	Name
bool	COMPUTE_GRAPH_ON = = MUDA_COMPUTE_GRAPH_ON
bool	DEBUG_VIEWER = = config::on(true)
bool	DEFAULT_ASYNC_ALLOC_FREE = = false
int	HEAVY_WORKLOAD_BLOCK_SIZE = = 64
int	LIGHT_WORKLOAD_BLOCK_SIZE = = 256
int	MIDDLE_WORKLOAD_BLOCK_SIZE = = 128
bool	RUNTIME_CHECK_ON = = MUDA_CHECK_ON
bool	TRAP_ON_ERROR = = config::on(true)
bool	always_false_v = = always_false<T>::value
bool	force_trivial_v = = force_trivial<T>::value
bool	force_trivially_constructible_v = = force_trivially_constructible<T>::value
bool	force_trivially_copy_assignable_v = =
force_trivially_copy_assignable<T>::value
bool	force_trivially_copy_constructible_v = =
force_trivially_copy_constructible<T>::value
bool	force_trivially_destructible_v = = force_trivially_destructible<T>::value
bool	is_cuda_arch_v = = is_cuda_arch::value
bool	is_read_only_view_v = = std::is_same_v<T, read_only_view_t<T>>
bool	is_read_write_view_v = = std::is_same_v<T, read_write_view_t<T>>
bool	is_trivial_v = = std::is_trivial_v<T> \|\| force_trivial_v<T>
bool	is_trivially_constructible_v = =
std::is_trivially_constructible_v<T> \|\| force_trivially_constructible_v<T>
bool	is_trivially_copy_assignable_v = =
std::is_trivially_copy_assignable_v<T> \|\| force_trivially_copy_assignable_v<T>
bool	is_trivially_copy_constructible_v = =
std::is_trivially_copy_constructible_v<T> \|\| force_trivially_copy_constructible_v<T>
bool	is_trivially_destructible_v = =
std::is_trivially_destructible_v<T> \|\| force_trivially_destructible_v<T>
bool	is_uniform_view_v = = is_read_only_view_v<T> && is_read_write_view_v<T>

Public Functions

Type	Name
	MUDA_DEFINE_ARITHMATIC_OPERATOR (+)
	MUDA_DEFINE_ARITHMATIC_OPERATOR (-)
	MUDA_DEFINE_COMPARISON_OPERATOR (<=)
	MUDA_DEFINE_COMPARISON_OPERATOR ()
MUDA_INLINE MUDA_GENERIC Extent2D	as_extent (const Offset2D & offset)
MUDA_INLINE MUDA_GENERIC Extent3D	as_extent (const Offset3D & offset)
MUDA_INLINE MUDA_GENERIC Offset2D	as_offset (const Extent2D & extent)
MUDA_INLINE MUDA_GENERIC Offset3D	as_offset (const Extent3D & extent)
__forceinline__ __device__ T	atomic_add (T * address, T val)
__forceinline__ __device__ T	atomic_and (T * address, T val)
__forceinline__ __device__ T	atomic_cas (T * address, T compare, T val)
__forceinline__ __device__ T	atomic_exch (T * address, T val)
__forceinline__ __device__ T	atomic_max (T * address, T val)
__forceinline__ __device__ T	atomic_min (T * address, T val)
__forceinline__ __device__ T	atomic_or (T * address, T val)
__forceinline__ __device__ T	atomic_sub (T * address, T val)
__forceinline__ __device__ T	atomic_xor (T * address, T val)
MUDA_INLINE MUDA_GENERIC dim3	block_dim ()
MUDA_INLINE MUDA_GENERIC dim3	block_idx ()
MUDA_INLINE MUDA_GENERIC void	brkpt ()
__host__ __device__ void	check (T result, char const const func, const char const file, int const line)
dim3	cube (int x)
cublasOperation_t	cublas_trans_operation (bool b)
cudaDataType_t	cuda_data_type ()
cusparseIndexType_t	cusparse_index_type ()
std::string_view	enum_name (ComputeGraphNodeType t)
MUDA_INLINE MUDA_GENERIC dim3	grid_dim ()
MUDA_GLOBAL void	grid_stride_loop_kernel (ParallelForCallable< F > f)
MUDA_INLINE MUDA_GENERIC decltype(auto)	invoke (FHost && host, FDevice && device)
MUDA_INLINE MUDA_GENERIC auto	make_cdense (const T * data)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_1d (const T * data, int dimx)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_1d (const T(&) data)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_2d (const T * data, const int2 & dim)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_2d (const T * data, int dimx, int dimy)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_3d (const T * data, const int3 & dim)
MUDA_INLINE MUDA_GENERIC auto	make_cdense_3d (const T * data, int dimx, int dimy, int dimz)
MUDA_INLINE MUDA_GENERIC auto	make_dense (T * data)
MUDA_INLINE MUDA_GENERIC auto	make_dense_1d (T * data, int dimx)
MUDA_INLINE MUDA_GENERIC auto	make_dense_1d (T(&) data)
MUDA_INLINE MUDA_GENERIC auto	make_dense_2d (T * data, const int2 & dim)
MUDA_INLINE MUDA_GENERIC auto	make_dense_2d (T * data, int dimx, int dimy)
MUDA_INLINE MUDA_GENERIC auto	make_dense_3d (T * data, const int3 & dim)
MUDA_INLINE MUDA_GENERIC auto	make_dense_3d (T * data, int dimx, int dimy, int dimz)
MUDA_INLINE MUDA_GENERIC Extent2D	max (const Extent2D & lhs, const Extent2D & rhs)
MUDA_INLINE MUDA_GENERIC Extent3D	max (const Extent3D & lhs, const Extent3D & rhs)
MUDA_INLINE MUDA_GENERIC Offset2D	min (const Offset2D & lhs, const Offset2D & rhs)
MUDA_INLINE MUDA_GENERIC Offset3D	min (const Offset3D & lhs, const Offset3D & rhs)
MUDA_INLINE MUDA_GENERIC const char *	mudaCudaGetErrorEnum (cusolverStatus_t error)
Empty	on (::cudaStream_t stream)
Empty	on ()
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags< BitType >	operator& (BitType bit, Flags< BitType > const & flags)
MUDA_INLINE MUDA_GENERIC int2	operator+ (const int2 & a, const int2 & b)
bool	operator< (ComputeGraphVarUsage lhs, ComputeGraphVarUsage rhs)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::Matrix< T, M, N > & val)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::Map< Eigen::Matrix< T, M, N >, MapOptions, StrideType > & val)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::Map< const Eigen::Matrix< T, M, N >, MapOptions, StrideType > & val)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::MatrixX< T > & val)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::VectorX< T > & val)
MUDA_DEVICE LogProxy	operator<< (LogProxy o, const Eigen::RowVectorX< T > & val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, char1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, char2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, char3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, char4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, short1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, short2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, short3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, short4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, int1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, int2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, int3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, int4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, long1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, long2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, long3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, long4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, longlong1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, longlong2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, longlong3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, longlong4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uchar1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uchar2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uchar3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uchar4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uint1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uint2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uint3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, uint4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulong1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulong2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulong3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulong4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulonglong1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulonglong2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulonglong3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, ulonglong4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, float1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, float2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, float3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, float4 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, double1 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, double2 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, double3 val)
MUDA_INLINE MUDA_DEVICE LogProxy	operator<< (LogProxy proxy, double4 val)
bool	operator<= (ComputeGraphVarUsage lhs, ComputeGraphVarUsage rhs)
bool	operator== (ComputeGraphVarUsage lhs, ComputeGraphVarUsage rhs)
bool	operator> (ComputeGraphVarUsage lhs, ComputeGraphVarUsage rhs)
bool	operator>= (ComputeGraphVarUsage lhs, ComputeGraphVarUsage rhs)
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags< BitType >	operator^ (BitType bit, Flags< BitType > const & flags)
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags< BitType >	operator\| (BitType bit, Flags< BitType > const & flags)
MUDA_GLOBAL void	parallel_for_kernel (ParallelForCallable< F > f)
MUDA_INLINE MUDA_GENERIC void	print (const char *const fmt, Args &&... arg)
MUDA_INLINE MUDA_GENERIC const T &	print_check (const T & t)
MUDA_INLINE MUDA_GENERIC auto	print_check (const char * t)
MUDA_INLINE MUDA_GENERIC OutType	print_convert (const InType & v)
MUDA_INLINE MUDA_GENERIC auto	print_convert (const char * v)
MUDA_INLINE MUDA_GENERIC const T &	print_convert (const Dense< T > & v)
MUDA_INLINE MUDA_GENERIC const T &	print_convert (const CDense< T > & v)
MUDA_HOST double	profile_host (F && f)
MUDA_GENERIC MUDA_INLINE constexpr T *	remove_const (const T * ptr) noexcept
MUDA_GENERIC MUDA_INLINE constexpr T &	remove_const (const T & ref) noexcept
dim3	square (int x)
MUDA_INLINE MUDA_GENERIC dim3	thread_idx ()
MUDA_INLINE MUDA_GENERIC void	trap ()
void	wait_device ()
void	wait_event (cudaEvent_t event)
void	wait_stream (::cudaStream_t stream)

Public Types Documentation

typedef BCOOMatrixView

using muda::BCOOMatrixView =  TripletMatrixView<T, N>;

typedef BCOOMatrixViewer

using muda::BCOOMatrixViewer =  CTripletMatrixViewer<T, N>;

typedef BCOOVectorView

using muda::BCOOVectorView =  DoubletVectorView<T, N>;

typedef BCOOVectorViewer

using muda::BCOOVectorViewer =  CDoubletVectorViewer<T, N>;

typedef BSRMatrixView

using muda::BSRMatrixView =  BSRMatrixViewT<false, Ty, N>;

typedef Buffer2DView

using muda::Buffer2DView =  Buffer2DViewT<false, T>;

typedef Buffer3DView

using muda::Buffer3DView =  Buffer3DViewT<false, T>;

typedef BufferView

using muda::BufferView =  BufferViewT<false, T>;

typedef CBCOOMatrixView

using muda::CBCOOMatrixView =  CTripletMatrixView<T, N>;

typedef CBCOOMatrixViewer

using muda::CBCOOMatrixViewer =  CTripletMatrixViewer<T, N>;

typedef CBCOOVectorView

using muda::CBCOOVectorView =  CDoubletVectorView<T, N>;

typedef CBCOOVectorViewer

using muda::CBCOOVectorViewer =  CDoubletVectorViewer<T, N>;

typedef CBSRMatrixView

using muda::CBSRMatrixView =  BSRMatrixViewT<true, Ty, N>;

typedef CBuffer2DView

using muda::CBuffer2DView =  Buffer2DViewT<true, T>;

typedef CBuffer3DView

using muda::CBuffer3DView =  Buffer3DViewT<true, T>;

typedef CBufferView

using muda::CBufferView =  BufferViewT<true, T>;

typedef CCOOMatrixView

using muda::CCOOMatrixView =  COOMatrixViewT<true, Ty>;

typedef CCOOMatrixViewer

using muda::CCOOMatrixViewer =  CBCOOMatrixViewer<T, 1>;

typedef CCOOVectorView

using muda::CCOOVectorView =  COOVectorViewBase<true, T>;

typedef CCOOVectorViewer

using muda::CCOOVectorViewer =  CBCOOVectorViewer<T, 1>;

typedef CCSRMatrixView

using muda::CCSRMatrixView =  CSRMatrixViewT<true, Ty>;

typedef CDense

using muda::CDense =  DenseViewerT<true, T>;

typedef CDense1D

using muda::CDense1D =  Dense1DT<true, T>;

typedef CDense2D

using muda::CDense2D =  Dense2DBase<true, T>;

typedef CDense3D

using muda::CDense3D =  Dense3DBase<true, T>;

typedef CDenseMatrixView

using muda::CDenseMatrixView =  DenseMatrixViewT<true, Ty>;

typedef CDenseMatrixViewer

using muda::CDenseMatrixViewer =  DenseMatrixViewerT<true, T>;

typedef CDenseVectorView

using muda::CDenseVectorView =  DenseVectorViewT<true, Ty>;

typedef CDenseVectorViewer

using muda::CDenseVectorViewer =  DenseVectorViewerT<true, T>;

typedef CDoubletVectorView

using muda::CDoubletVectorView =  DoubletVectorViewT<true, T, N>;

typedef CDoubletVectorViewer

using muda::CDoubletVectorViewer =  DoubletVectorViewerT<true, T, N>;

typedef COOMatrixView

using muda::COOMatrixView =  COOMatrixViewT<false, Ty>;

typedef COOMatrixViewer

using muda::COOMatrixViewer =  BCOOMatrixViewer<T, 1>;

typedef COOVectorView

using muda::COOVectorView =  COOVectorViewBase<false, T>;

typedef COOVectorViewer

using muda::COOVectorViewer =  BCOOVectorViewer<T, 1>;

typedef CSRMatrixView

using muda::CSRMatrixView =  CSRMatrixViewT<false, Ty>;

typedef CSRMatrixViewT

using muda::CSRMatrixViewT =  BSRMatrixViewT<IsConst, Ty, 1>;

typedef CTripletMatrixView

using muda::CTripletMatrixView =  TripletMatrixViewT<true, Ty, N>;

typedef CTripletMatrixViewer

using muda::CTripletMatrixViewer =  TripletMatrixViewerT<true, T, N>;

typedef CVarView

using muda::CVarView =  VarViewT<true, T>;

typedef ComputeGraphEventRecordNode

using muda::ComputeGraphEventRecordNode = 
    ComputeGraphNode<EventRecordNode, ComputeGraphNodeType::EventRecordNode>;

typedef ComputeGraphEventWaitNode

using muda::ComputeGraphEventWaitNode = 
    ComputeGraphNode<EventWaitNode, ComputeGraphNodeType::EventWaitNode>;

enum ComputeGraphFlag

enum muda::ComputeGraphFlag {
    HostLaunch = 1,
    DeviceLaunch = 2 | HostLaunch
};

typedef ComputeGraphKernelNode

using muda::ComputeGraphKernelNode = 
    ComputeGraphNode<KernelNode, ComputeGraphNodeType::KernelNode>;

typedef ComputeGraphMemcpyNode

using muda::ComputeGraphMemcpyNode = 
    ComputeGraphNode<MemcpyNode, ComputeGraphNodeType::MemcpyNode>;

typedef ComputeGraphMemsetNode

using muda::ComputeGraphMemsetNode = 
    ComputeGraphNode<MemsetNode, ComputeGraphNodeType::MemsetNode>;

enum ComputeGraphNodeType

enum muda::ComputeGraphNodeType {
    None,
    KernelNode,
    MemcpyNode,
    MemsetNode,
    CaptureNode,
    EventRecordNode,
    EventWaitNode,
    Max
};

enum ComputeGraphPhase

enum muda::ComputeGraphPhase {
    None,
    TopoBuilding,
    Building,
    Updating,
    SerialLaunching,
    Max
};

enum ComputeGraphVarUsage

enum muda::ComputeGraphVarUsage {
    None,
    Read,
    ReadWrite,
    Max
};

typedef DefaultTag

using muda::DefaultTag =  Tag<Default>;

typedef Dense

using muda::Dense =  DenseViewerT<false, T>;

typedef Dense1D

using muda::Dense1D =  Dense1DT<false, T>;

typedef Dense2D

using muda::Dense2D =  Dense2DBase<false, T>;

typedef Dense3D

using muda::Dense3D =  Dense3DBase<false, T>;

typedef DenseMatrixView

using muda::DenseMatrixView =  DenseMatrixViewT<false, Ty>;

typedef DenseMatrixViewer

using muda::DenseMatrixViewer =  DenseMatrixViewerT<false, T>;

typedef DenseVectorView

using muda::DenseVectorView =  DenseVectorViewT<false, Ty>;

typedef DenseVectorViewer

using muda::DenseVectorViewer =  DenseVectorViewerT<false, T>;

typedef DeviceCOOMatrix

using muda::DeviceCOOMatrix =  DeviceBCOOMatrix<T, 1>;

typedef DeviceCOOVector

using muda::DeviceCOOVector =  DeviceBCOOVector<T, 1>;

typedef DeviceCSRMatrix

using muda::DeviceCSRMatrix =  DeviceBSRMatrix<T, 1>;

typedef DoubletVectorView

using muda::DoubletVectorView =  DoubletVectorViewT<false, T, N>;

typedef DoubletVectorViewer

using muda::DoubletVectorViewer =  DoubletVectorViewerT<false, T, N>;

enum FieldEntryLayout

enum muda::FieldEntryLayout {
    None,
    AoS,
    SoA,
    AoSoA,
    RuntimeLayout
};

enum FieldEntryType

enum muda::FieldEntryType {
    None,
    Scalar,
    Vector,
    Matrix,
    Object
};

enum GraphInstantiateFlagBit

enum muda::GraphInstantiateFlagBit {
    FreeOnLaunch = CUgraphInstantiate_flags::CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH,
    Upload = 2,
    DeviceLaunch = 4,
    UseNodePriority = 8
};

typedef I32IdWithType

using muda::I32IdWithType =  IdWithType<int32_t>;

typedef I64IdWithType

using muda::I64IdWithType =  IdWithType<int64_t>;

typedef KeyValuePair

using muda::KeyValuePair =  cub::KeyValuePair<Key, Value>;

enum LinearSystemReorderMethod

enum muda::LinearSystemReorderMethod {
    None = 0,
    Symrcm = 1,
    Symamd = 2,
    Csrmetisnd = 3
};

enum LoggerBasicType

enum muda::LoggerBasicType {
    None,
    Int8,
    Int16,
    Int,
    Int32 = Int,
    Int64,
    Long,
    LongLong,
    UInt8,
    UInt16,
    UInt,
    UInt32 = UInt,
    UInt64,
    ULong,
    ULongLong,
    Float,
    Double,
    String,
    FmtString,
    Object
};

typedef LoggerFmtArg

using muda::LoggerFmtArg =  void (*)(void* formatter, const void* obj);

enum ParallelForType

enum muda::ParallelForType {
    DynamicBlocks,
    GridStrideLoop
};

typedef TripletMatrixView

using muda::TripletMatrixView =  TripletMatrixViewT<false, Ty, N>;

typedef TripletMatrixViewer

using muda::TripletMatrixViewer =  TripletMatrixViewerT<false, T, N>;

typedef U32IdWithType

using muda::U32IdWithType =  IdWithType<uint32_t>;

typedef U64IdWithType

using muda::U64IdWithType =  IdWithType<uint64_t>;

typedef VarView

using muda::VarView =  VarViewT<false, T>;

typedef raw_type_t

using muda::raw_type_t =  std::remove_all_extents_t<std::remove_reference_t<T>>;

typedef read_only_view_t

using muda::read_only_view_t =  typename read_only_view<T>::type;

typedef read_write_view_t

using muda::read_write_view_t =  typename read_write_view<T>::type;

typedef span

using muda::span =  tcb::span<T>;

Public Attributes Documentation

variable COMPUTE_GRAPH_ON

bool muda::COMPUTE_GRAPH_ON;

variable DEBUG_VIEWER

bool muda::DEBUG_VIEWER;

variable DEFAULT_ASYNC_ALLOC_FREE

bool muda::DEFAULT_ASYNC_ALLOC_FREE;

variable HEAVY_WORKLOAD_BLOCK_SIZE

int muda::HEAVY_WORKLOAD_BLOCK_SIZE;

variable LIGHT_WORKLOAD_BLOCK_SIZE

int muda::LIGHT_WORKLOAD_BLOCK_SIZE;

variable MIDDLE_WORKLOAD_BLOCK_SIZE

int muda::MIDDLE_WORKLOAD_BLOCK_SIZE;

variable RUNTIME_CHECK_ON

bool muda::RUNTIME_CHECK_ON;

variable TRAP_ON_ERROR

bool muda::TRAP_ON_ERROR;

variable always_false_v

bool muda::always_false_v;

variable force_trivial_v

bool muda::force_trivial_v;

variable force_trivially_constructible_v

bool muda::force_trivially_constructible_v;

variable force_trivially_copy_assignable_v

bool muda::force_trivially_copy_assignable_v;

variable force_trivially_copy_constructible_v

bool muda::force_trivially_copy_constructible_v;

variable force_trivially_destructible_v

bool muda::force_trivially_destructible_v;

variable is_cuda_arch_v

bool muda::is_cuda_arch_v;

variable is_read_only_view_v

bool muda::is_read_only_view_v;

variable is_read_write_view_v

bool muda::is_read_write_view_v;

variable is_trivial_v

bool muda::is_trivial_v;

variable is_trivially_constructible_v

bool muda::is_trivially_constructible_v;

variable is_trivially_copy_assignable_v

bool muda::is_trivially_copy_assignable_v;

variable is_trivially_copy_constructible_v

bool muda::is_trivially_copy_constructible_v;

variable is_trivially_destructible_v

bool muda::is_trivially_destructible_v;

variable is_uniform_view_v

bool muda::is_uniform_view_v;

Public Functions Documentation

function MUDA_DEFINE_ARITHMATIC_OPERATOR

muda::MUDA_DEFINE_ARITHMATIC_OPERATOR (
    +
)

function MUDA_DEFINE_ARITHMATIC_OPERATOR

muda::MUDA_DEFINE_ARITHMATIC_OPERATOR (
    -
)

function MUDA_DEFINE_COMPARISON_OPERATOR

muda::MUDA_DEFINE_COMPARISON_OPERATOR (
    <=
)

function MUDA_DEFINE_COMPARISON_OPERATOR

muda::MUDA_DEFINE_COMPARISON_OPERATOR ()

function as_extent

MUDA_INLINE MUDA_GENERIC Extent2D muda::as_extent (
    const Offset2D & offset
)

function as_extent

MUDA_INLINE MUDA_GENERIC Extent3D muda::as_extent (
    const Offset3D & offset
)

function as_offset

MUDA_INLINE MUDA_GENERIC Offset2D muda::as_offset (
    const Extent2D & extent
)

function as_offset

MUDA_INLINE MUDA_GENERIC Offset3D muda::as_offset (
    const Extent3D & extent
)

function atomic_add

template<typename T>
__forceinline__ __device__ T muda::atomic_add (
    T * address,
    T val
)

function atomic_and

template<typename T>
__forceinline__ __device__ T muda::atomic_and (
    T * address,
    T val
)

function atomic_cas

template<typename T>
__forceinline__ __device__ T muda::atomic_cas (
    T * address,
    T compare,
    T val
)

function atomic_exch

template<typename T>
__forceinline__ __device__ T muda::atomic_exch (
    T * address,
    T val
)

function atomic_max

template<typename T>
__forceinline__ __device__ T muda::atomic_max (
    T * address,
    T val
)

function atomic_min

template<typename T>
__forceinline__ __device__ T muda::atomic_min (
    T * address,
    T val
)

function atomic_or

template<typename T>
__forceinline__ __device__ T muda::atomic_or (
    T * address,
    T val
)

function atomic_sub

template<typename T>
__forceinline__ __device__ T muda::atomic_sub (
    T * address,
    T val
)

function atomic_xor

template<typename T>
__forceinline__ __device__ T muda::atomic_xor (
    T * address,
    T val
)

function block_dim

MUDA_INLINE MUDA_GENERIC dim3 muda::block_dim ()

function block_idx

MUDA_INLINE MUDA_GENERIC dim3 muda::block_idx ()

function brkpt

MUDA_INLINE MUDA_GENERIC void muda::brkpt ()

function check

template<typename T>
inline __host__ __device__ void muda::check (
    T result,
    char const *const func,
    const char *const file,
    int const line
)

function cube

dim3 muda::cube (
    int x
)

function cublas_trans_operation

cublasOperation_t muda::cublas_trans_operation (
    bool b
)

function cuda_data_type

template<typename T>
inline cudaDataType_t muda::cuda_data_type ()

function cusparse_index_type

template<typename T>
cusparseIndexType_t muda::cusparse_index_type ()

function enum_name

inline std::string_view muda::enum_name (
    ComputeGraphNodeType t
)

function grid_dim

MUDA_INLINE MUDA_GENERIC dim3 muda::grid_dim ()

function grid_stride_loop_kernel

template<typename F, typename UserTag>
MUDA_GLOBAL void muda::grid_stride_loop_kernel (
    ParallelForCallable< F > f
)

function invoke

template<typename FHost, typename FDevice>
MUDA_INLINE MUDA_GENERIC decltype(auto) muda::invoke (
    FHost && host,
    FDevice && device
)

function make_cdense

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense (
    const T * data
)

function make_cdense_1d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_1d (
    const T * data,
    int dimx
)

function make_cdense_1d

template<typename T, int N>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_1d (
    const T(&) data
)

function make_cdense_2d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_2d (
    const T * data,
    const int2 & dim
)

function make_cdense_2d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_2d (
    const T * data,
    int dimx,
    int dimy
)

function make_cdense_3d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_3d (
    const T * data,
    const int3 & dim
)

function make_cdense_3d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_cdense_3d (
    const T * data,
    int dimx,
    int dimy,
    int dimz
)

function make_dense

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense (
    T * data
)

function make_dense_1d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_1d (
    T * data,
    int dimx
)

function make_dense_1d

template<typename T, int N>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_1d (
    T(&) data
)

function make_dense_2d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_2d (
    T * data,
    const int2 & dim
)

function make_dense_2d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_2d (
    T * data,
    int dimx,
    int dimy
)

function make_dense_3d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_3d (
    T * data,
    const int3 & dim
)

function make_dense_3d

template<typename T>
MUDA_INLINE MUDA_GENERIC auto muda::make_dense_3d (
    T * data,
    int dimx,
    int dimy,
    int dimz
)

function max

MUDA_INLINE MUDA_GENERIC Extent2D muda::max (
    const Extent2D & lhs,
    const Extent2D & rhs
)

function max

MUDA_INLINE MUDA_GENERIC Extent3D muda::max (
    const Extent3D & lhs,
    const Extent3D & rhs
)

function min

MUDA_INLINE MUDA_GENERIC Offset2D muda::min (
    const Offset2D & lhs,
    const Offset2D & rhs
)

function min

MUDA_INLINE MUDA_GENERIC Offset3D muda::min (
    const Offset3D & lhs,
    const Offset3D & rhs
)

function mudaCudaGetErrorEnum

MUDA_INLINE MUDA_GENERIC const char * muda::mudaCudaGetErrorEnum (
    cusolverStatus_t error
)

function on

Empty muda::on (
    ::cudaStream_t stream
)

function on

Empty muda::on ()

function operator&

template<typename BitType>
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags < BitType > muda::operator& (
    BitType bit,
    Flags < BitType > const & flags
)

function operator+

MUDA_INLINE MUDA_GENERIC int2 muda::operator+ (
    const int2 & a,
    const int2 & b
)

function operator<

inline bool muda::operator< (
    ComputeGraphVarUsage lhs,
    ComputeGraphVarUsage rhs
)

function operator<<

template<typename T, int M, int N>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::Matrix< T, M, N > & val
)

function operator<<

template<typename T, int M, int N, int MapOptions, typename StrideType>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::Map< Eigen::Matrix< T, M, N >, MapOptions, StrideType > & val
)

function operator<<

template<typename T, int M, int N, int MapOptions, typename StrideType>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::Map< const Eigen::Matrix< T, M, N >, MapOptions, StrideType > & val
)

function operator<<

template<typename T>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::MatrixX< T > & val
)

function operator<<

template<typename T>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::VectorX< T > & val
)

function operator<<

template<typename T>
MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy o,
    const Eigen::RowVectorX< T > & val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    char1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    char2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    char3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    char4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    short1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    short2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    short3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    short4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    int1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    int2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    int3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    int4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    long1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    long2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    long3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    long4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    longlong1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    longlong2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    longlong3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    longlong4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uchar1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uchar2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uchar3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uchar4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uint1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uint2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uint3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    uint4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulong1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulong2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulong3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulong4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulonglong1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulonglong2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulonglong3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    ulonglong4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    float1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    float2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    float3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    float4 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    double1 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    double2 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    double3 val
)

function operator<<

MUDA_INLINE MUDA_DEVICE LogProxy muda::operator<< (
    LogProxy proxy,
    double4 val
)

function operator<=

inline bool muda::operator<= (
    ComputeGraphVarUsage lhs,
    ComputeGraphVarUsage rhs
)

function operator==

inline bool muda::operator== (
    ComputeGraphVarUsage lhs,
    ComputeGraphVarUsage rhs
)

function operator>

inline bool muda::operator> (
    ComputeGraphVarUsage lhs,
    ComputeGraphVarUsage rhs
)

function operator>=

inline bool muda::operator>= (
    ComputeGraphVarUsage lhs,
    ComputeGraphVarUsage rhs
)

function operator^

template<typename BitType>
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags < BitType > muda::operator^ (
    BitType bit,
    Flags < BitType > const & flags
)

function operator|

template<typename BitType>
MUDA_INLINE MUDA_GENERIC MUDA_CONSTEXPR Flags < BitType > muda::operator| (
    BitType bit,
    Flags < BitType > const & flags
)

function parallel_for_kernel

template<typename F, typename UserTag>
MUDA_GLOBAL void muda::parallel_for_kernel (
    ParallelForCallable< F > f
)

function print

template<typename... Args>
MUDA_INLINE MUDA_GENERIC void muda::print (
    const char *const fmt,
    Args &&... arg
)

function print_check

template<typename T>
MUDA_INLINE MUDA_GENERIC const T & muda::print_check (
    const T & t
)

function print_check

MUDA_INLINE MUDA_GENERIC auto muda::print_check (
    const char * t
)

function print_convert

template<typename InType, typename OutType>
MUDA_INLINE MUDA_GENERIC OutType muda::print_convert (
    const InType & v
)

function print_convert

MUDA_INLINE MUDA_GENERIC auto muda::print_convert (
    const char * v
)

function print_convert

template<typename T>
MUDA_INLINE MUDA_GENERIC const T & muda::print_convert (
    const Dense < T > & v
)

function print_convert

template<typename T>
MUDA_INLINE MUDA_GENERIC const T & muda::print_convert (
    const CDense < T > & v
)

function profile_host

template<typename F>
MUDA_HOST double muda::profile_host (
    F && f
)

function remove_const

template<typename T>
MUDA_GENERIC MUDA_INLINE constexpr T * muda::remove_const (
    const T * ptr
) noexcept

function remove_const

template<typename T>
MUDA_GENERIC MUDA_INLINE constexpr T & muda::remove_const (
    const T & ref
) noexcept

function square

dim3 muda::square (
    int x
)

function thread_idx

MUDA_INLINE MUDA_GENERIC dim3 muda::thread_idx ()

function trap

MUDA_INLINE MUDA_GENERIC void muda::trap ()

function wait_device

void muda::wait_device ()

function wait_event

void muda::wait_event (
    cudaEvent_t event
)

function wait_stream

void muda::wait_stream (
    ::cudaStream_t stream
)

The documentation for this class was generated from the following file src/muda/assert.h