CudaAlgorithmSrcMacros.h File Reference

Source part of macros set for image processing algorithm class for Cuda implementation. More...

#include <IPSDKImageProcessing/Algorithm/ImageProcessingAlgorithmSrcMacrosTypes.h>

Go to the source code of this file.

Macros
#define	IPSDKCUDA_CHECK_IMAGE_ON_GPU(image)
	Test if image is stored on GPU. More...
#define	IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU(r, data, IMAGE)   IPSDKCUDA_CHECK_IMAGE_ON_GPU(IMAGE)
	IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU on IMAGE. More...
#define	IPSDKGPU_CHECK_IMAGES_ON_GPU(IMAGES)   BOOST_PP_SEQ_FOR_EACH(IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU, _, IMAGES)
	Parse the iamge list to check if they are stored on GPU.
#define	IPSDKCUDA_TRY_TO_LAUNCH_PROCESS_ON_GPU()
	Calls the method tryToLaunchGpuProcess() If the calculation can be performed on GPU, the macro makes the retrieveProvider method return eRetrievalResultType::eRRT_NoMore to make IPSDK switch to classical CPU calculation. More...
#define	IPSDKCUDA_CHECK_PROCESS_CAN_BE_LAUNCHED_ON_GPU()
	Checks if the process can be launched on GPU. More...
#define	IPSDKCUDA_START_IMPLEMENT_LAUNCH_GPU_PROCESS(AlgoName)
	Implements the beginning of the body of the method tryToLaunchGpuProcess() in order to avoid code duplication. The macro parse all algorithm attributes and check if all the attribute images are loaded on GPU. If this condition is respected, The GPU lvl2 is dispatcher is created so that the user only have to initialize it. Otherwise, the function notify the retrieveProvider method that the process must be done on CPU. More...
#define	IPSDKCUDA_END_IMPLEMENT_LAUNCH_GPU_PROCESS()
	Implements the end of the body of the method tryToLaunchGpuProcess() in order to avoid code duplication. The macro checks the result of the dispathcer initialization and returns the appropriate result to manage CPU or GPU Lvl2 calculation. More...
#define	IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU(r, data, IMAGE)   IPSDKCUDA_CHECK_IMAGE_ON_GPU(IMAGE)
	IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU on IMAGE. More...
#define	IPSDKCUDA_CHECK_IMAGES_ON_GPU(IMAGES)   BOOST_PP_SEQ_FOR_EACH(IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU, _, IMAGES)
	Parse the iamge list to check if they are stored on GPU.

Detailed Description

Source part of macros set for image processing algorithm class for Cuda implementation.

Author

R. Abbal

Date

2022/08/03

Copyright

2022 Reactiv'IP, all right reserved.

Macro Definition Documentation

IPSDKCUDA_CHECK_IMAGE_ON_GPU

#define IPSDKCUDA_CHECK_IMAGE_ON_GPU

(

image

)

Value:

if (!image->getImagePtr()->isGpuImage())\
        return RetrievalResult(eRetrievalResultType::eRRT_Failed, image->getImagePtr()->getName() + " is not a GPU image");

Test if image is stored on GPU.

IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU [1/2]

#define IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU	(		r,
			data,
			IMAGE
	)		IPSDKCUDA_CHECK_IMAGE_ON_GPU(IMAGE)

IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU on IMAGE.

IPSDKCUDA_CHECK_IMAGE_ON_GPU on IMAGE.

IPSDKCUDA_TRY_TO_LAUNCH_PROCESS_ON_GPU

#define IPSDKCUDA_TRY_TO_LAUNCH_PROCESS_ON_GPU

(

)

Value:

RetrievalResult res = tryToLaunchGpuProcess(priority, pProvider);   \
    if (res.getResult() != eRetrievalResultType::eRRT_NoMore)           \
        return res;                                                     \

Calls the method tryToLaunchGpuProcess() If the calculation can be performed on GPU, the macro makes the retrieveProvider method return eRetrievalResultType::eRRT_NoMore to make IPSDK switch to classical CPU calculation.

IPSDKCUDA_CHECK_PROCESS_CAN_BE_LAUNCHED_ON_GPU

#define IPSDKCUDA_CHECK_PROCESS_CAN_BE_LAUNCHED_ON_GPU

(

)

Value:

ipBool bGpuCalculation = ipsdk::core::isGpuSupportActivated();                                                                      \
    if (bGpuCalculation) {                                                                                                              \
        const std::vector<std::string>& vAttributeNames = getAttributeNameColl();                                                       \
        for (const std::string& attributeName : vAttributeNames) {                                                                      \
            const BaseAttribute& curAttribute = getAttribute(attributeName);                                                            \
            if (curAttribute.isInit() && curAttribute.getAttributeType() == eAttributeType::eAT_ImageProcessing) {                      \
                const BaseImageAttribute* pImageAttribute = static_cast<const ipsdk::imaproc::BaseImageAttribute*>(&curAttribute);      \
                if (pImageAttribute->getImageProcessingAttributeType() == eImageProcessingAttributeType::eIPAT_Image) {                 \
                    const ipsdk::image::BaseImage& gpuImage = static_cast<const ipsdk::image::BaseImage&>(pImageAttribute->getImage()); \
                    bGpuCalculation = bGpuCalculation && gpuImage.isGpuImage();                                                         \
                }                                                                                                                       \
            }                                                                                                                           \
        }                                                                                                                               \
    }                                                                                                                                   \

Checks if the process can be launched on GPU.

IPSDKCUDA_START_IMPLEMENT_LAUNCH_GPU_PROCESS

#define IPSDKCUDA_START_IMPLEMENT_LAUNCH_GPU_PROCESS

(

AlgoName

)

Value:

IPSDKCUDA_CHECK_PROCESS_CAN_BE_LAUNCHED_ON_GPU()                                                                \
    if (bGpuCalculation) {                                                                                          \
        typedef StaticProcessorDispatcher<AlgoName> ProcessorDispatcher;                                            \
        boost::shared_ptr<ProcessorDispatcher> pProcessorDispatcher(boost::make_shared<ProcessorDispatcher>());

Implements the beginning of the body of the method tryToLaunchGpuProcess() in order to avoid code duplication. The macro parse all algorithm attributes and check if all the attribute images are loaded on GPU. If this condition is respected, The GPU lvl2 is dispatcher is created so that the user only have to initialize it. Otherwise, the function notify the retrieveProvider method that the process must be done on CPU.

Note

This macro, with IPSDKCUDA_END_IMPLEMENT_LAUNCH_GPU_PROCESS() simplify management of the GPU switch by letting the user only specify the dispatcher initialization

IPSDKCUDA_END_IMPLEMENT_LAUNCH_GPU_PROCESS

#define IPSDKCUDA_END_IMPLEMENT_LAUNCH_GPU_PROCESS

(

)

Value:

if (bInitRes.getResult() == true) {                                                 \
            pProvider = pProcessorDispatcher;                                               \
            return RetrievalResult(eRetrievalResultType::eRRT_Successful);                  \
        }                                                                                   \
        else                                                                                \
            return RetrievalResult(eRetrievalResultType::eRRT_Failed, bInitRes.getMsg());   \
    }                                                                                       \
    return RetrievalResult(eRetrievalResultType::eRRT_NoMore);

Implements the end of the body of the method tryToLaunchGpuProcess() in order to avoid code duplication. The macro checks the result of the dispathcer initialization and returns the appropriate result to manage CPU or GPU Lvl2 calculation.

Note

This macro, with IPSDKCUDA_START_IMPLEMENT_LAUNCH_GPU_PROCESS() simplify management of the GPU switch by letting the user only specify the dispatcher initialization

IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU [2/2]

#define IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU	(		r,
			data,
			IMAGE
	)		IPSDKCUDA_CHECK_IMAGE_ON_GPU(IMAGE)

IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU on IMAGE.

IPSDKCUDA_CHECK_IMAGE_ON_GPU on IMAGE.