Namespace muda

Namespaces

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

Classes

Type	Name
class	BSRMatrixViewBase <IsConst, typename Ty, N>
class	Buffer2DViewT <IsConst, typename T>
class	Buffer3DViewT <IsConst, typename T>
class	BufferLaunch
class	BufferViewT <IsConst, typename T>
class	CDenseMatrixView <typename Ty>
class	CDenseMatrixViewer <typename T>
class	CDenseVectorViewer <typename T>
class	CDoubletVectorViewer <typename T, N>
class	CDoubletVectorViewer< T, 1 > <typename T>
class	CFieldEntryView <typename T, Layout, M, N>
class	CMatrixMapInfo <typename T, M, N>
class	COOMatrixViewBase <IsConst, typename Ty>
class	COOVectorViewBase <IsConst, typename T>
class	CSRMatrixViewBase <IsConst, typename Ty>
class	CTripletMatrixViewer <typename T, N>
class	CTripletMatrixViewer< T, 1 > <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< Buffer2DView< T > > <typename T>
class	ComputeGraphVar< Buffer3DView< T > > <typename T>
class	ComputeGraphVar< BufferView< T > > <typename T>
class	ComputeGraphVar< GraphViewer > <>
class	ComputeGraphVar< VarView< T > > <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	DenseMatrixView <typename Ty>
class	DenseMatrixViewBase <IsConst, typename Ty>
class	DenseMatrixViewer <typename T>
class	DenseMatrixViewerBase <IsConst, typename T>
class	DenseVectorViewBase <IsConst, typename T>
class	DenseVectorViewer <typename T>
class	DenseVectorViewerBase <IsConst, typename T>
class	DenseViewerT <IsConst, typename T>
class	DeviceBCOOMatrix <typename T, N>
class	DeviceBCOOMatrix< Ty, 1 > <typename Ty>
class	DeviceBCOOVector <typename T, N>
class	DeviceBCOOVector< T, 1 > <typename T>
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	DeviceCSRMatrix <typename Ty>
class	DeviceDenseMatrix <typename Ty>
class	DeviceDenseVector <typename T>
class	DeviceDoubletVector <typename T, N>
class	DeviceDoubletVector< T, 1 > <typename T>
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	DeviceTripletMatrix< T, 1 > <typename T>
class	DeviceVar <typename T>
class	DeviceVector <typename T>
class	DoubletVectorViewBase <IsConst, typename T, N>
class	DoubletVectorViewBase< IsConst, T, 1 > <IsConst, typename T>
class	DoubletVectorViewer <typename T, N>
class	DoubletVectorViewer< T, 1 > <typename T>
class	DoubletVectorViewerBase <IsConst, typename T, N>
class	DoubletVectorViewerBase< IsConst, T, 1 > <IsConst, typename T>
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	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< FieldEntryLayout::AoS > <>
class	SubFieldImpl< FieldEntryLayout::AoSoA > <>
class	SubFieldImpl< FieldEntryLayout::SoA > <>
class	SubFieldInterface
struct	Tag <typename T>
class	TripletMatrixViewBase <IsConst, typename Ty, N>
class	TripletMatrixViewBase< IsConst, Ty, 1 > <IsConst, typename Ty>
class	TripletMatrixViewer <typename T, N>
class	TripletMatrixViewer< T, 1 > <typename T>
class	TripletMatrixViewerBase <IsConst, typename T, N>
class	TripletMatrixViewerBase< IsConst, T, 1 > <IsConst, typename T>
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_viewer <typename T>
struct	read_only_viewer< BSRMatrixView< Ty, N > > <typename Ty, N>
struct	read_only_viewer< Buffer2DView< T > > <typename T>
struct	read_only_viewer< Buffer3DView< T > > <typename T>
struct	read_only_viewer< BufferView< T > > <typename T>
struct	read_only_viewer< COOMatrixView< T > > <typename T>
struct	read_only_viewer< COOVectorView< T > > <typename T>
struct	read_only_viewer< CSRMatrixView< Ty > > <typename Ty>
struct	read_only_viewer< Dense1D< T > > <typename T>
struct	read_only_viewer< Dense2D< T > > <typename T>
struct	read_only_viewer< Dense3D< T > > <typename T>
struct	read_only_viewer< Dense< T > > <typename T>
struct	read_only_viewer< DenseVectorView< Ty > > <typename Ty>
struct	read_only_viewer< DenseVectorViewer< T > > <typename T>
struct	read_only_viewer< DoubletVectorView< Ty, N > > <typename Ty, N>
struct	read_only_viewer< FieldEntryView< T, Layout, M, N > > <typename T, Layout, M, N>
struct	read_only_viewer< GraphViewer > <>
struct	*read_only_viewer< T >** <typename T>
struct	read_only_viewer< TripletMatrixView< Ty, N > > <typename Ty, N>
struct	read_only_viewer< VarView< T > > <typename T>
struct	read_only_viewer< cudaEvent_t > <>
struct	read_only_viewer< lbvh::BVHViewer< Real, Object > > <typename Real, typename Object>
struct	read_write_viewer <typename T>
struct	read_write_viewer< CBSRMatrixView< Ty, N > > <typename Ty, N>
struct	read_write_viewer< CBuffer2DView< T > > <typename T>
struct	read_write_viewer< CBuffer3DView< T > > <typename T>
struct	read_write_viewer< CBufferView< T > > <typename T>
struct	read_write_viewer< CCOOMatrixView< T > > <typename T>
struct	read_write_viewer< CCOOVectorView< T > > <typename T>
struct	read_write_viewer< CDense1D< T > > <typename T>
struct	read_write_viewer< CDense2D< T > > <typename T>
struct	read_write_viewer< CDense3D< T > > <typename T>
struct	read_write_viewer< CDense< T > > <typename T>
struct	read_write_viewer< CDenseVectorViewer< T > > <typename T>
struct	read_write_viewer< CDoubletVectorView< Ty, N > > <typename Ty, N>
struct	read_write_viewer< CFieldEntryView< T, Layout, M, N > > <typename T, Layout, M, N>
struct	read_write_viewer< CSRMatrixView< Ty > > <typename Ty>
struct	read_write_viewer< CVarView< T > > <typename T>
struct	read_write_viewer< DenseVectorView< Ty > > <typename Ty>
struct	read_write_viewer< GraphViewer > <>
struct	read_write_viewer< TripletMatrixView< Ty, N > > <typename Ty, N>
struct	*read_write_viewer< const T >** <typename T>
struct	read_write_viewer< cudaEvent_t > <>
struct	read_write_viewer< lbvh::CBVHViewer< Real, Object > > <typename Real, typename Object>
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 BSRMatrixViewBase< 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 BSRMatrixViewBase< true, Ty, N >	CBSRMatrixView
typedef Buffer2DViewT< true, T >	CBuffer2DView
typedef Buffer3DViewT< true, T >	CBuffer3DView
typedef BufferViewT< true, T >	CBufferView
typedef COOMatrixViewBase< true, Ty >	CCOOMatrixView
typedef CBCOOMatrixViewer< T, 1 >	CCOOMatrixViewer
typedef COOVectorViewBase< true, T >	CCOOVectorView
typedef CBCOOVectorViewer< T, 1 >	CCOOVectorViewer
typedef CSRMatrixViewBase< true, Ty >	CCSRMatrixView
typedef DenseViewerT< true, T >	CDense
typedef Dense1DT< true, T >	CDense1D
typedef Dense2DBase< true, T >	CDense2D
typedef Dense3DBase< true, T >	CDense3D
typedef DenseVectorViewBase< true, Ty >	CDenseVectorView
typedef DoubletVectorViewBase< true, T, N >	CDoubletVectorView
typedef COOMatrixViewBase< false, Ty >	COOMatrixView
typedef BCOOMatrixViewer< T, 1 >	COOMatrixViewer
typedef COOVectorViewBase< false, T >	COOVectorView
typedef BCOOVectorViewer< T, 1 >	COOVectorViewer
typedef CSRMatrixViewBase< false, Ty >	CSRMatrixView
typedef TripletMatrixViewBase< true, Ty, N >	CTripletMatrixView
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 DenseVectorViewBase< false, Ty >	DenseVectorView
typedef DeviceBCOOMatrix< T, 1 >	DeviceCOOMatrix
typedef DeviceBCOOVector< T, 1 >	DeviceCOOVector
typedef DoubletVectorViewBase< false, T, N >	DoubletVectorView
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 TripletMatrixViewBase< false, Ty, N >	TripletMatrixView
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_viewer< T >::type	read_only_viewer_t
typedef typename read_write_viewer< T >::type	read_write_viewer_t
typedef tcb::span< T >	span

Public Attributes

Type	Name
constexpr bool	COMPUTE_GRAPH_ON = = MUDA_COMPUTE_GRAPH_ON
constexpr bool	DEBUG_VIEWER = = config::on(true)
constexpr bool	DEFAULT_ASYNC_ALLOC_FREE = = false
constexpr int	HEAVY_WORKLOAD_BLOCK_SIZE = = 64
constexpr int	LIGHT_WORKLOAD_BLOCK_SIZE = = 256
constexpr int	MIDDLE_WORKLOAD_BLOCK_SIZE = = 128
constexpr bool	RUNTIME_CHECK_ON = = MUDA_CHECK_ON
constexpr bool	TRAP_ON_ERROR = = config::on(true)
constexpr bool	always_false_v = = always_false<T>::value
constexpr bool	force_trivial_v = = force_trivial<T>::value
constexpr bool	force_trivially_constructible_v = = force_trivially_constructible<T>::value
constexpr bool	force_trivially_copy_assignable_v = =
force_trivially_copy_assignable<T>::value
constexpr bool	force_trivially_copy_constructible_v = =
force_trivially_copy_constructible<T>::value
constexpr bool	force_trivially_destructible_v = = force_trivially_destructible<T>::value
constexpr bool	is_cuda_arch_v = = is_cuda_arch::value
constexpr bool	is_read_only_viewer_v = = std::is_same_v<T, read_only_viewer_t<T>>
constexpr bool	is_read_write_viewer_v = = std::is_same_v<T, read_write_viewer_t<T>>
constexpr bool	is_trivial_v = = std::is_trivial_v<T> \|\| force_trivial_v<T>
constexpr bool	is_trivially_constructible_v = =
std::is_trivially_constructible_v<T> \|\| force_trivially_constructible_v<T>
constexpr bool	is_trivially_copy_assignable_v = =
std::is_trivially_copy_assignable_v<T> \|\| force_trivially_copy_assignable_v<T>
constexpr bool	is_trivially_copy_constructible_v = =
std::is_trivially_copy_constructible_v<T> \|\| force_trivially_copy_constructible_v<T>
constexpr bool	is_trivially_destructible_v = =
std::is_trivially_destructible_v<T> \|\| force_trivially_destructible_v<T>
constexpr bool	is_uniform_viewer_v = =
is_read_only_viewer_v<T> && is_read_write_viewer_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)
constexpr cublasOperation_t	cublas_trans_operation (bool b)
constexpr cudaDataType_t	cuda_data_type ()
constexpr cusparseIndexType_t	cusparse_index_type ()
std::string_view	enum_name (ComputeGraphNodeType t)
MUDA_INLINE MUDA_GENERIC dim3	grid_dim ()
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_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 T *	remove_const (const T * ptr) noexcept
MUDA_GENERIC MUDA_INLINE 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 = typedef TripletMatrixView<T, N>;

typedef BCOOMatrixViewer

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

typedef BCOOVectorView

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

typedef BCOOVectorViewer

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

typedef BSRMatrixView

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

typedef Buffer2DView

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

typedef Buffer3DView

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

typedef BufferView

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

typedef CBCOOMatrixView

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

typedef CBCOOMatrixViewer

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

typedef CBCOOVectorView

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

typedef CBCOOVectorViewer

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

typedef CBSRMatrixView

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

typedef CBuffer2DView

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

typedef CBuffer3DView

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

typedef CBufferView

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

typedef CCOOMatrixView

using muda::CCOOMatrixView = typedef COOMatrixViewBase<true, Ty>;

typedef CCOOMatrixViewer

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

typedef CCOOVectorView

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

typedef CCOOVectorViewer

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

typedef CCSRMatrixView

using muda::CCSRMatrixView = typedef CSRMatrixViewBase<true, Ty>;

typedef CDense

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

typedef CDense1D

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

typedef CDense2D

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

typedef CDense3D

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

typedef CDenseVectorView

using muda::CDenseVectorView = typedef DenseVectorViewBase<true, Ty>;

typedef CDoubletVectorView

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

typedef COOMatrixView

using muda::COOMatrixView = typedef COOMatrixViewBase<false, Ty>;

typedef COOMatrixViewer

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

typedef COOVectorView

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

typedef COOVectorViewer

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

typedef CSRMatrixView

using muda::CSRMatrixView = typedef CSRMatrixViewBase<false, Ty>;

typedef CTripletMatrixView

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

typedef CVarView

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

typedef ComputeGraphEventRecordNode

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

typedef ComputeGraphEventWaitNode

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

enum ComputeGraphFlag

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

typedef ComputeGraphKernelNode

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

typedef ComputeGraphMemcpyNode

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

typedef ComputeGraphMemsetNode

using muda::ComputeGraphMemsetNode = typedef 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 = typedef Tag<Default>;

typedef Dense

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

typedef Dense1D

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

typedef Dense2D

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

typedef Dense3D

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

typedef DenseVectorView

using muda::DenseVectorView = typedef DenseVectorViewBase<false, Ty>;

typedef DeviceCOOMatrix

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

typedef DeviceCOOVector

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

typedef DoubletVectorView

using muda::DoubletVectorView = typedef DoubletVectorViewBase<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 = typedef IdWithType<int32_t>;

typedef I64IdWithType

using muda::I64IdWithType = typedef IdWithType<int64_t>;

typedef KeyValuePair

using muda::KeyValuePair = typedef 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 = typedef void (*)(void* formatter, const void* obj);

enum ParallelForType

enum muda::ParallelForType {
    DynamicBlocks,
    GridStrideLoop
};

typedef TripletMatrixView

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

typedef U32IdWithType

using muda::U32IdWithType = typedef IdWithType<uint32_t>;

typedef U64IdWithType

using muda::U64IdWithType = typedef IdWithType<uint64_t>;

typedef VarView

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

typedef raw_type_t

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

typedef read_only_viewer_t

using muda::read_only_viewer_t = typedef typename read_only_viewer<T>::type;

typedef read_write_viewer_t

using muda::read_write_viewer_t = typedef typename read_write_viewer<T>::type;

typedef span

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

Public Attributes Documentation

variable COMPUTE_GRAPH_ON

constexpr bool muda::COMPUTE_GRAPH_ON;

variable DEBUG_VIEWER

constexpr bool muda::DEBUG_VIEWER;

variable DEFAULT_ASYNC_ALLOC_FREE

constexpr bool muda::DEFAULT_ASYNC_ALLOC_FREE;

variable HEAVY_WORKLOAD_BLOCK_SIZE

constexpr int muda::HEAVY_WORKLOAD_BLOCK_SIZE;

variable LIGHT_WORKLOAD_BLOCK_SIZE

constexpr int muda::LIGHT_WORKLOAD_BLOCK_SIZE;

variable MIDDLE_WORKLOAD_BLOCK_SIZE

constexpr int muda::MIDDLE_WORKLOAD_BLOCK_SIZE;

variable RUNTIME_CHECK_ON

constexpr bool muda::RUNTIME_CHECK_ON;

variable TRAP_ON_ERROR

constexpr bool muda::TRAP_ON_ERROR;

variable always_false_v

constexpr bool muda::always_false_v;

variable force_trivial_v

constexpr bool muda::force_trivial_v;

variable force_trivially_constructible_v

constexpr bool muda::force_trivially_constructible_v;

variable force_trivially_copy_assignable_v

constexpr bool muda::force_trivially_copy_assignable_v;

variable force_trivially_copy_constructible_v

constexpr bool muda::force_trivially_copy_constructible_v;

variable force_trivially_destructible_v

constexpr bool muda::force_trivially_destructible_v;

variable is_cuda_arch_v

constexpr bool muda::is_cuda_arch_v;

variable is_read_only_viewer_v

constexpr bool muda::is_read_only_viewer_v;

variable is_read_write_viewer_v

constexpr bool muda::is_read_write_viewer_v;

variable is_trivial_v

constexpr bool muda::is_trivial_v;

variable is_trivially_constructible_v

constexpr bool muda::is_trivially_constructible_v;

variable is_trivially_copy_assignable_v

constexpr bool muda::is_trivially_copy_assignable_v;

variable is_trivially_copy_constructible_v

constexpr bool muda::is_trivially_copy_constructible_v;

variable is_trivially_destructible_v

constexpr bool muda::is_trivially_destructible_v;

variable is_uniform_viewer_v

constexpr bool muda::is_uniform_viewer_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

constexpr cublasOperation_t muda::cublas_trans_operation (
    bool b
)

function cuda_data_type

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

function cusparse_index_type

template<typename T>
constexpr 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 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 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 T * muda::remove_const (
    const T * ptr
) noexcept

function remove_const

template<typename T>
MUDA_GENERIC MUDA_INLINE 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