open3d::core Namespace Reference

Namespaces
namespace	cuda
namespace	eigen_converter
namespace	kernel
namespace	linalg
namespace	nns
namespace	shape_util
namespace	sy
namespace	tensor_check
namespace	tensor_init

Data Structures
class	AdvancedIndexPreprocessor
	This class is based on PyTorch's aten/src/ATen/native/Indexing.cpp. More...
class	AdvancedIndexer
class	Blob
class	CUDAScopedDevice
	When CUDA is not enabled, this is a dummy class. More...
class	Device
class	IsDevice
class	Dtype
struct	FunctionTraits
struct	FunctionTraits< T ClassType::* >
struct	FunctionTraits< ReturnType(ClassType::*)(Args...) const >
struct	FunctionTraits< T & >
struct	FunctionTraits< T * >
struct	FunctionTraits< ReturnType(Args...)>
struct	NullaryFunctionTraits
struct	UnaryFunctionTraits
struct	BinaryFunctionTraits
class	CPUHashBackendBufferAccessor
class	TBBHashBackend
class	CUDAHashBackendBufferAccessor
class	SlabHashBackend
class	SlabHashBackendImpl
class	Slab
class	SlabNodeManagerImpl
class	SlabNodeManager
struct	iterator_t
struct	Pair
class	StdGPUAllocator
class	StdGPUHashBackend
struct	ValueExtractor
class	DeviceHashBackend
class	HashBackendBuffer
class	HashMap
class	HashSet
struct	OffsetCalculator
struct	TensorRef
	A minimalistic class that reference a Tensor. More...
class	TensorIterator
class	Indexer
class	IndexerIterator
class	MemoryManager
class	MemoryManagerDevice
	Interface for all concrete memory manager classes. More...
class	MemoryManagerCached
class	MemoryManagerCPU
struct	SizeOrder
struct	PointerOrder
struct	VirtualBlock
struct	RealBlock
class	MemoryCache
class	Cacher
class	MemoryManagerStatistic
class	Scalar
class	DynamicSizeVector
class	SizeVector
class	iterator_range
class	SmallVectorBase
struct	SmallVectorAlignmentAndSize
	Figure out the offset of the first element. More...
class	SmallVectorTemplateCommon
class	SmallVectorTemplateBase
class	SmallVectorTemplateBase< T, true >
class	SmallVectorImpl
struct	SmallVectorStorage
struct	SmallVectorStorage< T, 0 >
struct	CalculateSmallVectorDefaultInlinedElements
class	SmallVector
class	StdAllocator
class	Open3DDLManagedTensor
	Open3D DLPack Tensor manager. More...
class	Tensor
class	TensorKey
	TensorKey is used to represent single index, slice or advanced indexing on a Tensor. More...
class	TensorList

Typedefs
template<typename Key>
using	InternalStdGPUHashBackendAllocator
template<typename Key, typename Hash, typename Eq>
using	InternalStdGPUHashBackend
using	buf_index_t = uint32_t
template<class T>
using	SmallVectorSizeType
template<typename RangeType>
using	ValueTypeFromRangeType

Enumerations
enum class	HashBackendType { Slab , StdGPU , TBB , Default }
enum class	DtypePolicy { NONE , ALL_SAME , INPUT_SAME , INPUT_SAME_OUTPUT_BOOL }

Functions
uint32_t	AtomicFetchAddRelaxed (uint32_t *address, uint32_t val)
uint64_t	AtomicFetchAddRelaxed (uint64_t *address, uint64_t val)
void	CPUResetHeap (Tensor &heap)
std::shared_ptr< DeviceHashBackend >	CreateCPUHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
	Non-templated factory.
template<typename Key, typename Hash, typename Eq>
__global__ void	InsertKernelPass0 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void *input_keys, buf_index_t *output_buf_indices, int heap_counter_prev, int64_t count)
	Kernels.
template<typename Key, typename Hash, typename Eq>
__global__ void	InsertKernelPass1 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq, typename block_t>
__global__ void	InsertKernelPass2 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void *const *input_values_soa, buf_index_t *output_buf_indices, bool *output_masks, int64_t count, int64_t n_values)
template<typename Key, typename Hash, typename Eq>
__global__ void	FindKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, const void *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq>
__global__ void	EraseKernelPass0 (SlabHashBackendImpl< Key, Hash, Eq > impl, const void *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq>
__global__ void	EraseKernelPass1 (SlabHashBackendImpl< Key, Hash, Eq > impl, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq>
__global__ void	GetActiveIndicesKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, buf_index_t *output_buf_indices, uint32_t *output_count)
template<typename Key, typename Hash, typename Eq>
__global__ void	CountElemsPerBucketKernel (SlabHashBackendImpl< Key, Hash, Eq > impl, int64_t *bucket_elem_counts)
__global__ void	CountSlabsPerSuperblockKernel (SlabNodeManagerImpl impl, uint32_t *slabs_per_superblock)
template<typename First, typename Second>
OPEN3D_HOST_DEVICE Pair< First, Second >	make_pair (const First &_first, const Second &_second)
template<typename Key, typename Hash, typename Eq>
__global__ void	STDGPUFindKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq>
__global__ void	STDGPUEraseKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)
template<typename Key, typename Hash, typename Eq, typename block_t>
__global__ void	STDGPUInsertKernel (InternalStdGPUHashBackend< Key, Hash, Eq > map, CUDAHashBackendBufferAccessor buffer_accessor, const Key *input_keys, const void *const *input_values_soa, buf_index_t *output_buf_indices, bool *output_masks, int64_t count, int64_t n_values)
std::shared_ptr< DeviceHashBackend >	CreateDeviceHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
std::shared_ptr< DeviceHashBackend >	CreateCUDAHashBackend (int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
void	AddMM (const Tensor &A, const Tensor &B, Tensor &output, double alpha, double beta)
void	AddMMCPU (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype)
void	AddMMCUDA (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype, const Device &device)
void	AddMMSYCL (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, double alpha, double beta, bool gemmTrA, bool gemmTrB, int lda, int ldb, int ldc, Dtype dtype, const Device &device)
template<typename scalar_t>
void	gemm_cpu (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, scalar_t alpha, const scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, const scalar_t *B_data, OPEN3D_CPU_LINALG_INT ldb, scalar_t beta, scalar_t *C_data, OPEN3D_CPU_LINALG_INT ldc)
template<>
void	gemm_cpu< float > (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, float alpha, const float *A_data, OPEN3D_CPU_LINALG_INT lda, const float *B_data, OPEN3D_CPU_LINALG_INT ldb, float beta, float *C_data, OPEN3D_CPU_LINALG_INT ldc)
template<>
void	gemm_cpu< double > (CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, double alpha, const double *A_data, OPEN3D_CPU_LINALG_INT lda, const double *B_data, OPEN3D_CPU_LINALG_INT ldb, double beta, double *C_data, OPEN3D_CPU_LINALG_INT ldc)
double	Det (const Tensor &A)
void	Inverse (const Tensor &A, Tensor &output)
	Computes A^{-1} with LU factorization, where A is a N x N square matrix.
void	InverseCPU (void *A_data, void *ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)
void	InverseCUDA (void *A_data, void *ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)
void	InverseSYCL (void *A_data, void *ipiv_data, void *output_data, int64_t n, Dtype dtype, const Device &device)
template<typename scalar_t>
OPEN3D_CPU_LINALG_INT	getrf_cpu (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<typename scalar_t>
OPEN3D_CPU_LINALG_INT	getri_cpu (int layout, OPEN3D_CPU_LINALG_INT n, scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<typename scalar_t>
OPEN3D_CPU_LINALG_INT	gesv_cpu (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data, scalar_t *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<typename scalar_t>
OPEN3D_CPU_LINALG_INT	gels_cpu (int matrix_layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<typename scalar_t>
OPEN3D_CPU_LINALG_INT	gesvd_cpu (int matrix_layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t *A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t *S_data, scalar_t *U_data, OPEN3D_CPU_LINALG_INT ldu, scalar_t *VT_data, OPEN3D_CPU_LINALG_INT ldvt, scalar_t *superb)
template<>
OPEN3D_CPU_LINALG_INT	getrf_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<>
OPEN3D_CPU_LINALG_INT	getrf_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<>
OPEN3D_CPU_LINALG_INT	getri_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT n, float *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<>
OPEN3D_CPU_LINALG_INT	getri_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT n, double *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data)
template<>
OPEN3D_CPU_LINALG_INT	gesv_cpu< float > (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, float *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data, float *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<>
OPEN3D_CPU_LINALG_INT	gesv_cpu< double > (int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, double *A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT *ipiv_data, double *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<>
OPEN3D_CPU_LINALG_INT	gels_cpu< float > (int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, float *A_data, OPEN3D_CPU_LINALG_INT lda, float *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<>
OPEN3D_CPU_LINALG_INT	gels_cpu< double > (int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, double *A_data, OPEN3D_CPU_LINALG_INT lda, double *B_data, OPEN3D_CPU_LINALG_INT ldb)
template<>
OPEN3D_CPU_LINALG_INT	gesvd_cpu< float > (int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float *A_data, OPEN3D_CPU_LINALG_INT lda, float *S_data, float *U_data, OPEN3D_CPU_LINALG_INT ldu, float *VT_data, OPEN3D_CPU_LINALG_INT ldvt, float *superb)
template<>
OPEN3D_CPU_LINALG_INT	gesvd_cpu< double > (int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double *A_data, OPEN3D_CPU_LINALG_INT lda, double *S_data, double *U_data, OPEN3D_CPU_LINALG_INT ldu, double *VT_data, OPEN3D_CPU_LINALG_INT ldvt, double *superb)
void	LeastSquares (const Tensor &A, const Tensor &B, Tensor &X)
	Solve AX = B with QR decomposition. A is a full-rank m x n matrix (m >= n).
void	LeastSquaresCPU (void *A_data, void *B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	LeastSquaresCUDA (void *A_data, void *B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	LeastSquaresSYCL (void *A_data, void *B_data, int64_t m, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	OPEN3D_LAPACK_CHECK (OPEN3D_CPU_LINALG_INT info, const std::string &msg)
void	LUIpiv (const Tensor &A, Tensor &ipiv, Tensor &output)
void	LU (const Tensor &A, Tensor &permutation, Tensor &lower, Tensor &upper, const bool permute_l)
void	LUCPU (void *A_data, void *ipiv_data, int64_t rows, int64_t cols, Dtype dtype, const Device &device)
void	LUCUDA (void *A_data, void *ipiv_data, int64_t rows, int64_t cols, Dtype dtype, const Device &device)
void	LUSYCL (void *A_data, void *ipiv_data, int64_t m, int64_t n, Dtype dtype, const Device &device)
void	Matmul (const Tensor &A, const Tensor &B, Tensor &C)
	Computes matrix multiplication C = AB.
void	MatmulCPU (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype)
void	MatmulCUDA (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype, const Device &device)
void	MatmulSYCL (void *A_data, void *B_data, void *C_data, int64_t m, int64_t k, int64_t n, Dtype dtype, const Device &device)
void	Solve (const Tensor &A, const Tensor &B, Tensor &X)
	Solve AX = B with LU decomposition. A is a square matrix.
void	SolveCPU (void *A_data, void *B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	SolveCUDA (void *A_data, void *B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	SolveSYCL (void *A_data, void *B_data, void *ipiv_data, int64_t n, int64_t k, Dtype dtype, const Device &device)
void	SVD (const Tensor &A, Tensor &U, Tensor &S, Tensor &VT)
void	SVDCPU (const void *A_data, void *U_data, void *S_data, void *VT_data, void *superb_data, int64_t m, int64_t n, Dtype dtype, const Device &device)
void	SVDCUDA (const void *A_data, void *U_data, void *S_data, void *VT_data, void *superb_data, int64_t m, int64_t n, Dtype dtype, const Device &device)
void	SVDSYCL (const void *A_data, void *U_data, void *S_data, void *VT_data, int64_t m, int64_t n, Dtype dtype, const Device &device)
void	Triu (const Tensor &A, Tensor &output, const int diagonal)
void	Tril (const Tensor &A, Tensor &output, const int diagonal)
void	Triul (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)
void	TriuCPU (const Tensor &A, Tensor &output, const int diagonal)
void	TrilCPU (const Tensor &A, Tensor &output, const int diagonal)
void	TriulCPU (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)
void	TriuSYCL (const Tensor &A, Tensor &output, const int diagonal)
void	TrilSYCL (const Tensor &A, Tensor &output, const int diagonal)
void	TriulSYCL (const Tensor &A, Tensor &upper, Tensor &lower, const int diagonal)
template<typename func_t>
void	ParallelForCPU_ (const Device &device, int64_t n, const func_t &func)
	Run a function in parallel on CPU.
template<typename func_t>
void	ParallelFor (const Device &device, int64_t n, const func_t &func)
template<typename vec_func_t, typename func_t>
void	ParallelFor (const Device &device, int64_t n, const func_t &func, const vec_func_t &vec_func)
template<typename Functor, typename... FuncArgs>
void	ParallelForSYCL (const Device &device, Indexer indexer, FuncArgs... func_args)
	Run a function in parallel with SYCL.
template<typename Functor, typename... FuncArgs>
void	ParallelForSYCL (const Device &device, int64_t num_workloads, FuncArgs... func_args)
	Run a function in parallel with SYCL.
void *	safe_malloc (size_t Sz)
void *	safe_realloc (void *Ptr, size_t Sz)
template<typename T, unsigned N>
size_t	capacity_in_bytes (const SmallVector< T, N > &X)
template<unsigned Size, typename R>
SmallVector< ValueTypeFromRangeType< R >, Size >	to_vector (R &&Range)
template<typename R>
SmallVector< ValueTypeFromRangeType< R >, CalculateSmallVectorDefaultInlinedElements< ValueTypeFromRangeType< R > >::value >	to_vector (R &&Range)
template<typename T>
Tensor	operator+ (T scalar_lhs, const Tensor &rhs)
template<typename T>
Tensor	operator- (T scalar_lhs, const Tensor &rhs)
template<typename T>
Tensor	operator* (T scalar_lhs, const Tensor &rhs)
template<typename T>
Tensor	operator/ (T scalar_lhs, const Tensor &rhs)
void	AssertNotSYCL (const Tensor &tensor)
Tensor	Concatenate (const std::vector< Tensor > &tensors, const utility::optional< int64_t > &axis=0)
	Concatenates the list of tensors in their order, along the given axis into a new tensor. All the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be concatenated. Using Concatenate for a single tensor, the tensor is split along its first dimension (length), and concatenated along the axis.
Tensor	Append (const Tensor &self, const Tensor &other, const utility::optional< int64_t > &axis=utility::nullopt)
	Appends the two tensors, along the given axis into a new tensor. Both the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be appended.
Tensor	Maximum (const Tensor &input, const Tensor &other)
	Computes the element-wise maximum of input and other. The tensors must have same data type and device.
Tensor	Minimum (const Tensor &input, const Tensor &other)
	Computes the element-wise minimum of input and other. The tensors must have same data type and device.

Variables
const Dtype	Undefined = Dtype::Undefined
const Dtype	Float32 = Dtype::Float32
const Dtype	Float64 = Dtype::Float64
const Dtype	Int8 = Dtype::Int8
const Dtype	Int16 = Dtype::Int16
const Dtype	Int32 = Dtype::Int32
const Dtype	Int64 = Dtype::Int64
const Dtype	UInt8 = Dtype::UInt8
const Dtype	UInt16 = Dtype::UInt16
const Dtype	UInt32 = Dtype::UInt32
const Dtype	UInt64 = Dtype::UInt64
const Dtype	Bool = Dtype::Bool
template<typename T, unsigned N>
class LLVM_GSL_OWNER	SmallVector
constexpr utility::nullopt_t	None {utility::nullopt_t::init()}

Typedef Documentation

buf_index_t

using open3d::core::buf_index_t = uint32_t

InternalStdGPUHashBackend

template<typename Key, typename Hash, typename Eq>

using open3d::core::InternalStdGPUHashBackend

Initial value:

 
        stdgpu::unordered_map<Key,
                              buf_index_t,
                              Hash,
                              Eq,
                              InternalStdGPUHashBackendAllocator<Key>>

InternalStdGPUHashBackendAllocator

template<typename Key>

using open3d::core::InternalStdGPUHashBackendAllocator

Initial value:

 
        StdGPUAllocator<stdgpu::pair<const Key, buf_index_t>>

SmallVectorSizeType

template<class T>

using open3d::core::SmallVectorSizeType

Initial value:

 
        typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8,
                                  uint64_t,
                                  uint32_t>::type

ValueTypeFromRangeType

template<typename RangeType>

using open3d::core::ValueTypeFromRangeType

Initial value:

 
        typename std::remove_const<typename std::remove_reference<decltype(
                *std::begin(std::declval<RangeType &>()))>::type>::type

Enumeration Type Documentation

DtypePolicy

enum class open3d::core::DtypePolicy

strong

Enumerator
NONE
ALL_SAME
INPUT_SAME
INPUT_SAME_OUTPUT_BOOL

HashBackendType

enum class open3d::core::HashBackendType

strong

Enumerator
Slab
StdGPU
TBB
Default

Function Documentation

AddMM()

void open3d::core::AddMM	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	C,
		double	alpha,
		double	beta )

Computes matrix multiplication C = alpha * A @ B + beta * C. If matrix A is a (n x m) tensor, and B is a (m x p) tensor, C should have a shape (n x p). alpha and beta are scaling factors on matrix-matrix multiplication and the added matrix input respectively.

AddMMCPU()

void open3d::core::AddMMCPU	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype )

AddMMCUDA()

void open3d::core::AddMMCUDA	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype,
		const Device &	device )

AddMMSYCL()

void open3d::core::AddMMSYCL	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		double	alpha,
		double	beta,
		bool	gemmTrA,
		bool	gemmTrB,
		int	lda,
		int	ldb,
		int	ldc,
		Dtype	dtype,
		const Device &	device )

Append()

Tensor open3d::core::Append	(	const Tensor &	self,
		const Tensor &	other,
		const utility::optional< int64_t > &	axis = utility::nullopt )

Appends the two tensors, along the given axis into a new tensor. Both the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be appended.

This is the same as NumPy's semantics:

• https://numpy.org/doc/stable/reference/generated/numpy.append.html

Example:

Tensor a = Tensor::Init<int64_t>({{0, 1}, {2, 3}});
Tensor b = Tensor::Init<int64_t>({{4, 5}});
Tensor t1 = core::Append(a, b, 0);
// t1:
//  [[0 1],
//   [2 3],
//   [4 5]]
//  Tensor[shape={3, 2}, stride={2, 1}, Int64, CPU:0, 0x55555abc6b00]
 
Tensor t2 = core::Append(a, b);
// t2:
//  [0 1 2 3 4 5]
//  Tensor[shape={6}, stride={1}, Int64, CPU:0, 0x55555abc6b70]

Parameters

self	Values are appended to a copy of this tensor.
other	Values of this tensor is appended to the self.
axis	[optional] The axis along which values are appended. If axis is not given, both tensors are flattened before use.

Returns

A copy of tensor with values appended to axis. Note that append does not occur in-place: a new array is allocated and filled. If axis is None, out is a flattened tensor.

AssertNotSYCL()

void open3d::core::AssertNotSYCL ( const Tensor & tensor )

inline

AtomicFetchAddRelaxed() [1/2]

uint32_t open3d::core::AtomicFetchAddRelaxed ( uint32_t * address, uint32_t val )

inline

Adds val to the value stored at address and returns the previous stored value as an atomic operation. This function does not impose any ordering on concurrent memory accesses.

Warning

This function will treat all values as signed integers on Windows!

AtomicFetchAddRelaxed() [2/2]

uint64_t open3d::core::AtomicFetchAddRelaxed ( uint64_t * address, uint64_t val )

inline

Adds val to the value stored at address and returns the previous stored value as an atomic operation. This function does not impose any ordering on concurrent memory accesses.

Warning

This function will treat all values as signed integers on Windows!

capacity_in_bytes()

template<typename T, unsigned N>

size_t open3d::core::capacity_in_bytes ( const SmallVector< T, N > & X )

inline

Concatenate()

Tensor open3d::core::Concatenate	(	const std::vector< Tensor > &	tensors,
		const utility::optional< int64_t > &	axis = 0 )

Concatenates the list of tensors in their order, along the given axis into a new tensor. All the tensors must have same data-type, device, and number of dimensions. All dimensions must be the same, except the dimension along the axis the tensors are to be concatenated. Using Concatenate for a single tensor, the tensor is split along its first dimension (length), and concatenated along the axis.

This is the same as NumPy's semantics:

• https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html

Example:

Tensor a = Tensor::Init<int64_t>({{0, 1}, {2, 3}});
Tensor b = Tensor::Init<int64_t>({{4, 5}});
Tensor c = Tensor::Init<int64_t>({{6, 7}});
Tensor output = core::Concatenate({a, b, c}, 0);
// output:
//  [[0 1],
//   [2 3],
//   [4 5],
//   [6 7]]
//  Tensor[shape={4, 2}, stride={2, 1}, Int64, CPU:0, 0x55555abc6b00]
 
a = core::Tensor::Init<float>(
        {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}, {{8, 9}, {10, 11}}}, device);
output = core::Concatenate({a}, 1);
//  output:
//  [[0, 1, 4, 5, 8, 9],
//   [2, 3, 6, 7, 10, 11]]
//  Tensor[shape={2, 6}, stride={6, 1}, Int64, CPU:0, 0x55555abc6b00]

Parameters

tensors	Vector of tensors to be concatenated. If only one tensor is present, the tensor is split along its first dimension (length), and concatenated along the axis.
axis	[optional] The axis along which values are concatenated. [Default axis is 0].

Returns

A new tensor with the values of list of tensors concatenated in order, along the given axis.

CountElemsPerBucketKernel()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::CountElemsPerBucketKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		int64_t *	bucket_elem_counts )

CountSlabsPerSuperblockKernel()

__global__ void open3d::core::CountSlabsPerSuperblockKernel	(	SlabNodeManagerImpl	impl,
		uint32_t *	slabs_per_superblock )

CPUResetHeap()

void open3d::core::CPUResetHeap

(

Tensor &

heap

)

CreateCPUHashBackend()

std::shared_ptr< DeviceHashBackend > open3d::core::CreateCPUHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend )

Non-templated factory.

CreateCUDAHashBackend()

std::shared_ptr< DeviceHashBackend > open3d::core::CreateCUDAHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend )

CreateDeviceHashBackend()

std::shared_ptr< DeviceHashBackend > open3d::core::CreateDeviceHashBackend	(	int64_t	init_capacity,
		const Dtype &	key_dtype,
		const SizeVector &	key_element_shape,
		const std::vector< Dtype > &	value_dtypes,
		const std::vector< SizeVector > &	value_element_shapes,
		const Device &	device,
		const HashBackendType &	backend )

Factory functions:

• Default constructor switch is in DeviceHashBackend.cpp
• Default CPU constructor is in CPU/CreateCPUHashBackend.cpp
• Default CUDA constructor is in CUDA/CreateCUDAHashBackend.cu

Det()

double open3d::core::Det

(

const Tensor &

A

)

EraseKernelPass0()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::EraseKernelPass0	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

EraseKernelPass1()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::EraseKernelPass1	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

FindKernel()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::FindKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

gels_cpu()

template<typename scalar_t>

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu ( int matrix_layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gels_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu< double > ( int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, double * A_data, OPEN3D_CPU_LINALG_INT lda, double * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gels_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gels_cpu< float > ( int layout, char trans, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT nrhs, float * A_data, OPEN3D_CPU_LINALG_INT lda, float * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gemm_cpu()

template<typename scalar_t>

void open3d::core::gemm_cpu ( CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, scalar_t alpha, const scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, const scalar_t * B_data, OPEN3D_CPU_LINALG_INT ldb, scalar_t beta, scalar_t * C_data, OPEN3D_CPU_LINALG_INT ldc )

inline

gemm_cpu< double >()

template<>

void open3d::core::gemm_cpu< double > ( CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, double alpha, const double * A_data, OPEN3D_CPU_LINALG_INT lda, const double * B_data, OPEN3D_CPU_LINALG_INT ldb, double beta, double * C_data, OPEN3D_CPU_LINALG_INT ldc )

inline

gemm_cpu< float >()

template<>

void open3d::core::gemm_cpu< float > ( CBLAS_LAYOUT layout, CBLAS_TRANSPOSE trans_A, CBLAS_TRANSPOSE trans_B, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT k, float alpha, const float * A_data, OPEN3D_CPU_LINALG_INT lda, const float * B_data, OPEN3D_CPU_LINALG_INT ldb, float beta, float * C_data, OPEN3D_CPU_LINALG_INT ldc )

inline

gesv_cpu()

template<typename scalar_t>

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu ( int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data, scalar_t * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gesv_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu< double > ( int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, double * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data, double * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gesv_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesv_cpu< float > ( int layout, OPEN3D_CPU_LINALG_INT n, OPEN3D_CPU_LINALG_INT m, float * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data, float * B_data, OPEN3D_CPU_LINALG_INT ldb )

inline

gesvd_cpu()

template<typename scalar_t>

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu ( int matrix_layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, scalar_t * S_data, scalar_t * U_data, OPEN3D_CPU_LINALG_INT ldu, scalar_t * VT_data, OPEN3D_CPU_LINALG_INT ldvt, scalar_t * superb )

inline

gesvd_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu< double > ( int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double * A_data, OPEN3D_CPU_LINALG_INT lda, double * S_data, double * U_data, OPEN3D_CPU_LINALG_INT ldu, double * VT_data, OPEN3D_CPU_LINALG_INT ldvt, double * superb )

inline

gesvd_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::gesvd_cpu< float > ( int layout, char jobu, char jobvt, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float * A_data, OPEN3D_CPU_LINALG_INT lda, float * S_data, float * U_data, OPEN3D_CPU_LINALG_INT ldu, float * VT_data, OPEN3D_CPU_LINALG_INT ldvt, float * superb )

inline

GetActiveIndicesKernel()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::GetActiveIndicesKernel	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		buf_index_t *	output_buf_indices,
		uint32_t *	output_count )

getrf_cpu()

template<typename scalar_t>

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu ( int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

getrf_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu< double > ( int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, double * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

getrf_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getrf_cpu< float > ( int layout, OPEN3D_CPU_LINALG_INT m, OPEN3D_CPU_LINALG_INT n, float * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

getri_cpu()

template<typename scalar_t>

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu ( int layout, OPEN3D_CPU_LINALG_INT n, scalar_t * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

getri_cpu< double >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu< double > ( int layout, OPEN3D_CPU_LINALG_INT n, double * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

getri_cpu< float >()

template<>

OPEN3D_CPU_LINALG_INT open3d::core::getri_cpu< float > ( int layout, OPEN3D_CPU_LINALG_INT n, float * A_data, OPEN3D_CPU_LINALG_INT lda, OPEN3D_CPU_LINALG_INT * ipiv_data )

inline

InsertKernelPass0()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::InsertKernelPass0	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		int	heap_counter_prev,
		int64_t	count )

Kernels.

InsertKernelPass1()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::InsertKernelPass1	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

InsertKernelPass2()

template<typename Key, typename Hash, typename Eq, typename block_t>

__global__ void open3d::core::InsertKernelPass2	(	SlabHashBackendImpl< Key, Hash, Eq >	impl,
		const void *const *	input_values_soa,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count,
		int64_t	n_values )

Inverse()

void open3d::core::Inverse	(	const Tensor &	A,
		Tensor &	output )

Computes A^{-1} with LU factorization, where A is a N x N square matrix.

InverseCPU()

void open3d::core::InverseCPU	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

InverseCUDA()

void open3d::core::InverseCUDA	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

InverseSYCL()

void open3d::core::InverseSYCL	(	void *	A_data,
		void *	ipiv_data,
		void *	output_data,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

LeastSquares()

void open3d::core::LeastSquares	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	X )

Solve AX = B with QR decomposition. A is a full-rank m x n matrix (m >= n).

LeastSquaresCPU()

void open3d::core::LeastSquaresCPU	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

LeastSquaresCUDA()

void open3d::core::LeastSquaresCUDA	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

LeastSquaresSYCL()

void open3d::core::LeastSquaresSYCL	(	void *	A_data,
		void *	B_data,
		int64_t	m,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

LU()

void open3d::core::LU	(	const Tensor &	A,
		Tensor &	permutation,
		Tensor &	lower,
		Tensor &	upper,
		const bool	permute_l )

LUCPU()

void open3d::core::LUCPU	(	void *	A_data,
		void *	ipiv_data,
		int64_t	rows,
		int64_t	cols,
		Dtype	dtype,
		const Device &	device )

LUCUDA()

void open3d::core::LUCUDA	(	void *	A_data,
		void *	ipiv_data,
		int64_t	rows,
		int64_t	cols,
		Dtype	dtype,
		const Device &	device )

LUIpiv()

void open3d::core::LUIpiv	(	const Tensor &	A,
		Tensor &	ipiv,
		Tensor &	output )

LUSYCL()

void open3d::core::LUSYCL	(	void *	A_data,
		void *	ipiv_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

make_pair()

template<typename First, typename Second>

OPEN3D_HOST_DEVICE Pair< First, Second > open3d::core::make_pair	(	const First &	_first,
		const Second &	_second )

Matmul()

void open3d::core::Matmul	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	output )

Computes matrix multiplication C = AB.

MatmulCPU()

void open3d::core::MatmulCPU	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype )

MatmulCUDA()

void open3d::core::MatmulCUDA	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

MatmulSYCL()

void open3d::core::MatmulSYCL	(	void *	A_data,
		void *	B_data,
		void *	C_data,
		int64_t	m,
		int64_t	k,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

Maximum()

Tensor open3d::core::Maximum	(	const Tensor &	input,
		const Tensor &	other )

Computes the element-wise maximum of input and other. The tensors must have same data type and device.

If input.GetShape() != other.GetShape(), then they will be broadcasted to a common shape (which becomes the shape of the output).

Parameters

input	The input tensor.
other	The second input tensor.

Minimum()

Tensor open3d::core::Minimum	(	const Tensor &	input,
		const Tensor &	other )

Computes the element-wise minimum of input and other. The tensors must have same data type and device.

If input.GetShape() != other.GetShape(), then they will be broadcasted to a common shape (which becomes the shape of the output).

Parameters

input	The input tensor.
other	The second input tensor.

OPEN3D_LAPACK_CHECK()

void open3d::core::OPEN3D_LAPACK_CHECK ( OPEN3D_CPU_LINALG_INT info, const std::string & msg )

inline

operator*()

template<typename T>

Tensor open3d::core::operator* ( T scalar_lhs, const Tensor & rhs )

inline

operator+()

template<typename T>

Tensor open3d::core::operator+ ( T scalar_lhs, const Tensor & rhs )

inline

operator-()

template<typename T>

Tensor open3d::core::operator- ( T scalar_lhs, const Tensor & rhs )

inline

operator/()

template<typename T>

Tensor open3d::core::operator/ ( T scalar_lhs, const Tensor & rhs )

inline

ParallelFor() [1/2]

template<typename func_t>

void open3d::core::ParallelFor	(	const Device &	device,
		int64_t	n,
		const func_t &	func )

Run a function in parallel on CPU or CUDA.

Parameters

device	The device for the parallel for loop to run on.
n	The number of workloads.
func	The function to be executed in parallel. The function should take an int64_t workload index and returns void, i.e., void func(int64_t).

Note

This is optimized for uniform work items, i.e. where each call to func takes the same time.

If you use a lambda function, capture only the required variables instead of all to prevent accidental race conditions. If you want the kernel to be used on both CPU and CUDA, capture the variables by value.

This does not dispatch to SYCL, since SYCL has extra constraints:

• Lambdas may capture by value only.
• No function pointers / virtual functions. Auto dispatch to SYCL will enforce these conditions even on CPU devices. Use ParallelForSYCL instead.

ParallelFor() [2/2]

template<typename vec_func_t, typename func_t>

void open3d::core::ParallelFor	(	const Device &	device,
		int64_t	n,
		const func_t &	func,
		const vec_func_t &	vec_func )

Run a potentially vectorized function in parallel on CPU or CUDA.

Parameters

device	The device for the parallel for loop to run on.
n	The number of workloads.
func	The function to be executed in parallel. The function should take an int64_t workload index and returns void, i.e., void func(int64_t).
vec_func	The vectorized function to be executed in parallel. The function should be provided using the OPEN3D_VECTORIZED macro, e.g., OPEN3D_VECTORIZED(MyISPCKernel, some_used_variable).

Note

This is optimized for uniform work items, i.e. where each call to func takes the same time.

If you use a lambda function, capture only the required variables instead of all to prevent accidental race conditions. If you want the kernel to be used on both CPU and CUDA, capture the variables by value.

Example:

/* MyFile.cpp */
#ifdef BUILD_ISPC_MODULE
#include "MyFile_ispc.h"
#endif
 
std::vector<float> v(1000);
float fill_value = 42.0f;
core::ParallelFor(
        core::Device("CPU:0"),
        v.size(),
        [&](int64_t idx) { v[idx] = fill_value; },
        OPEN3D_VECTORIZED(MyFillKernel, v.data(), fill_value));
 
/* MyFile.ispc */
#include "open3d/core/ParallelFor.isph"
 
static inline void MyFillFunction(int64_t idx,
                                  float* uniform v,
                                  uniform float fill_value) {
    v[idx] = fill_value;
}
 
OPEN3D_EXPORT_VECTORIZED(MyFillKernel,
                         MyFillFunction,
                         float* uniform,
                         uniform float)

ParallelForCPU_()

template<typename func_t>

void open3d::core::ParallelForCPU_	(	const Device &	device,
		int64_t	n,
		const func_t &	func )

Run a function in parallel on CPU.

ParallelForSYCL() [1/2]

template<typename Functor, typename... FuncArgs>

void open3d::core::ParallelForSYCL	(	const Device &	device,
		Indexer	indexer,
		FuncArgs...	func_args )

Run a function in parallel with SYCL.

TODO: Specify grid size based on device properties

ParallelForSYCL() [2/2]

template<typename Functor, typename... FuncArgs>

void open3d::core::ParallelForSYCL	(	const Device &	device,
		int64_t	num_workloads,
		FuncArgs...	func_args )

Run a function in parallel with SYCL.

TODO: Specify grid size based on device properties

safe_malloc()

void * open3d::core::safe_malloc ( size_t Sz )

inline

safe_realloc()

void * open3d::core::safe_realloc ( void * Ptr, size_t Sz )

inline

Solve()

void open3d::core::Solve	(	const Tensor &	A,
		const Tensor &	B,
		Tensor &	X )

Solve AX = B with LU decomposition. A is a square matrix.

SolveCPU()

void open3d::core::SolveCPU	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

SolveCUDA()

void open3d::core::SolveCUDA	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

SolveSYCL()

void open3d::core::SolveSYCL	(	void *	A_data,
		void *	B_data,
		void *	ipiv_data,
		int64_t	n,
		int64_t	k,
		Dtype	dtype,
		const Device &	device )

STDGPUEraseKernel()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::STDGPUEraseKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

STDGPUFindKernel()

template<typename Key, typename Hash, typename Eq>

__global__ void open3d::core::STDGPUFindKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count )

STDGPUInsertKernel()

template<typename Key, typename Hash, typename Eq, typename block_t>

__global__ void open3d::core::STDGPUInsertKernel	(	InternalStdGPUHashBackend< Key, Hash, Eq >	map,
		CUDAHashBackendBufferAccessor	buffer_accessor,
		const Key *	input_keys,
		const void *const *	input_values_soa,
		buf_index_t *	output_buf_indices,
		bool *	output_masks,
		int64_t	count,
		int64_t	n_values )

SVD()

void open3d::core::SVD	(	const Tensor &	A,
		Tensor &	U,
		Tensor &	S,
		Tensor &	VT )

Computes SVD decomposition A = U S VT, where A is an m x n, U is an m x m, S is a min(m, n), VT is an n x n tensor.

SVDCPU()

void open3d::core::SVDCPU	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		void *	superb_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

SVDCUDA()

void open3d::core::SVDCUDA	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		void *	superb_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

SVDSYCL()

void open3d::core::SVDSYCL	(	const void *	A_data,
		void *	U_data,
		void *	S_data,
		void *	VT_data,
		int64_t	m,
		int64_t	n,
		Dtype	dtype,
		const Device &	device )

to_vector() [1/2]

template<typename R>

SmallVector< ValueTypeFromRangeType< R >, CalculateSmallVectorDefaultInlinedElements< ValueTypeFromRangeType< R > >::value > open3d::core::to_vector

(

R &&

Range

)

to_vector() [2/2]

template<unsigned Size, typename R>

SmallVector< ValueTypeFromRangeType< R >, Size > open3d::core::to_vector

(

R &&

Range

)

Given a range of type R, iterate the entire range and return a SmallVector with elements of the vector. This is useful, for example, when you want to iterate a range and then sort the results.

Tril()

void open3d::core::Tril	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

TrilCPU()

void open3d::core::TrilCPU	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

TrilSYCL()

void open3d::core::TrilSYCL	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

Triu()

void open3d::core::Triu	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

TriuCPU()

void open3d::core::TriuCPU	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

Triul()

void open3d::core::Triul	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal )

TriulCPU()

void open3d::core::TriulCPU	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal )

TriulSYCL()

void open3d::core::TriulSYCL	(	const Tensor &	A,
		Tensor &	upper,
		Tensor &	lower,
		const int	diagonal )

TriuSYCL()

void open3d::core::TriuSYCL	(	const Tensor &	A,
		Tensor &	output,
		const int	diagonal )

Variable Documentation

Bool

OPEN3D_API const Dtype open3d::core::Bool = Dtype::Bool

Float32

OPEN3D_API const Dtype open3d::core::Float32 = Dtype::Float32

Float64

OPEN3D_API const Dtype open3d::core::Float64 = Dtype::Float64

Int16

OPEN3D_API const Dtype open3d::core::Int16 = Dtype::Int16

Int32

OPEN3D_API const Dtype open3d::core::Int32 = Dtype::Int32

Int64

OPEN3D_API const Dtype open3d::core::Int64 = Dtype::Int64

Int8

OPEN3D_API const Dtype open3d::core::Int8 = Dtype::Int8

None

utility::nullopt_t open3d::core::None {utility::nullopt_t::init()}

constexpr

SmallVector

template<typename T, unsigned N>

class LLVM_GSL_OWNER open3d::core::SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference sizeof(SmallVector<T, 0>).

UInt16

OPEN3D_API const Dtype open3d::core::UInt16 = Dtype::UInt16

UInt32

OPEN3D_API const Dtype open3d::core::UInt32 = Dtype::UInt32

UInt64

OPEN3D_API const Dtype open3d::core::UInt64 = Dtype::UInt64

UInt8

OPEN3D_API const Dtype open3d::core::UInt8 = Dtype::UInt8

Undefined

OPEN3D_API const Dtype open3d::core::Undefined = Dtype::Undefined