ParallelFor.h File Reference

(9238339 (Tue Mar 14 18:49:09 2023 -0700))

#include <cstdint>
#include <type_traits>
#include "open3d/core/Device.h"
#include "open3d/utility/Logging.h"
#include "open3d/utility/Overload.h"
#include "open3d/utility/Parallel.h"
#include "open3d/utility/Preprocessor.h"

Go to the source code of this file.

Namespaces
	open3d
	open3d::core

Macros
#define	OPEN3D_CALL_ISPC_KERNEL_(ISPCKernel, start, end, ...)
#define	OPEN3D_OVERLOADED_LAMBDA_(T, ISPCKernel, ...)
	Internal helper macro. More...
#define	OPEN3D_VECTORIZED(ISPCKernel, ...)
#define	OPEN3D_TEMPLATE_VECTORIZED(T, ISPCKernel, ...)

Functions
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. More...
template<typename func_t >
void	open3d::core::ParallelFor (const Device &device, int64_t n, const func_t &func)
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)

Macro Definition Documentation

OPEN3D_CALL_ISPC_KERNEL_

#define OPEN3D_CALL_ISPC_KERNEL_	(		ISPCKernel,
			start,
			end,
			...
	)

Value:

    utility::LogError(                                                   \
            "ISPC module disabled. Unable to call vectorized kernel {}", \
            OPEN3D_STRINGIFY(ISPCKernel));

OPEN3D_OVERLOADED_LAMBDA_

#define OPEN3D_OVERLOADED_LAMBDA_	(		T,
			ISPCKernel,
			...
	)

Value:

    [&](T, int64_t start, int64_t end) {                                    \
        OPEN3D_CALL_ISPC_KERNEL_(                                           \
                OPEN3D_CONCAT(ISPCKernel, OPEN3D_CONCAT(_, T)), start, end, \
                __VA_ARGS__);                                               \
    }

Internal helper macro.

OPEN3D_TEMPLATE_VECTORIZED

#define OPEN3D_TEMPLATE_VECTORIZED	(		T,
			ISPCKernel,
			...
	)

Value:

    [&](int64_t start, int64_t end) {                                         \
        static_assert(std::is_arithmetic<T>::value,                           \
                      "Data type is not an arithmetic type");                 \
        utility::Overload(                                                    \
                OPEN3D_OVERLOADED_LAMBDA_(bool, ISPCKernel, __VA_ARGS__),     \
                OPEN3D_OVERLOADED_LAMBDA_(uint8_t, ISPCKernel, __VA_ARGS__),  \
                OPEN3D_OVERLOADED_LAMBDA_(int8_t, ISPCKernel, __VA_ARGS__),   \
                OPEN3D_OVERLOADED_LAMBDA_(uint16_t, ISPCKernel, __VA_ARGS__), \
                OPEN3D_OVERLOADED_LAMBDA_(int16_t, ISPCKernel, __VA_ARGS__),  \
                OPEN3D_OVERLOADED_LAMBDA_(uint32_t, ISPCKernel, __VA_ARGS__), \
                OPEN3D_OVERLOADED_LAMBDA_(int32_t, ISPCKernel, __VA_ARGS__),  \
                OPEN3D_OVERLOADED_LAMBDA_(uint64_t, ISPCKernel, __VA_ARGS__), \
                OPEN3D_OVERLOADED_LAMBDA_(int64_t, ISPCKernel, __VA_ARGS__),  \
                OPEN3D_OVERLOADED_LAMBDA_(float, ISPCKernel, __VA_ARGS__),    \
                OPEN3D_OVERLOADED_LAMBDA_(double, ISPCKernel, __VA_ARGS__),   \
                [&](auto&& generic, int64_t start, int64_t end) {             \
                    utility::LogError(                                        \
                            "Unsupported data type {} for calling "           \
                            "vectorized kernel {}",                           \
                            typeid(generic).name(),                           \
                            OPEN3D_STRINGIFY(ISPCKernel));                    \
                })(T{}, start, end);                                          \
    }

OPEN3D_TEMPLATE_VECTORIZED(T, ISPCKernel, ...)

Defines a lambda function to call the provided template-like kernel. Supported types:

• bool
• unsigned + signed {8,16,32,64} bit integers,
• float, double

Use the OPEN3D_EXPORT_TEMPLATE_VECTORIZED macro to define the kernel in the ISPC source file.

Note: The arguments to the kernel only have to exist if ISPC support is enabled via BUILD_ISPC_MODULE=ON.

OPEN3D_VECTORIZED

#define OPEN3D_VECTORIZED	(		ISPCKernel,
			...
	)

Value:

    [&](int64_t start, int64_t end) {                                  \
        OPEN3D_CALL_ISPC_KERNEL_(ISPCKernel, start, end, __VA_ARGS__); \
    }

OPEN3D_VECTORIZED(ISPCKernel, ...)

Defines a lambda function to call the provided kernel.

Use the OPEN3D_EXPORT_TEMPLATE_VECTORIZED macro to define the kernel in the ISPC source file.

Note: The arguments to the kernel only have to exist if ISPC support is enabled via BUILD_ISPC_MODULE=ON.