CudaAlgorithmSrcMacros.h

Go to the documentation of this file.

// CudaAlgorithmSrcMacros.h:
// ------------------------------------
//

#ifndef __IPSDKIMAGEPROCESSING_CUDAALGORITHMSRCMACROS_H__
#define __IPSDKIMAGEPROCESSING_CUDAALGORITHMSRCMACROS_H__

//#include <IPSDKBaseProcessing/Algorithm/ProcessingAlgorithmSrcMacros.h>
//#include <IPSDKImageProcessing/Algorithm/Function/AlgorithmFunctionEfficiency.h>
#include <IPSDKImageProcessing/Algorithm/ImageProcessingAlgorithmSrcMacrosTypes.h>

// Macro for GPU processing
// ===========================================================================//

// ---- Test if a set of images is stored on GPU
#define IPSDKCUDA_CHECK_IMAGE_ON_GPU(image) \
    if (!image->getImagePtr()->isGpuImage())\
        return RetrievalResult(eRetrievalResultType::eRRT_Failed, image->getImagePtr()->getName() + " is not a GPU image");

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


#define IPSDKGPU_CHECK_IMAGES_ON_GPU(IMAGES) BOOST_PP_SEQ_FOR_EACH(IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU, _, IMAGES)

//=========================================
//=========================================
#define IPSDKCUDA_TRY_TO_LAUNCH_PROCESS_ON_GPU()                        \
    RetrievalResult res = tryToLaunchGpuProcess(priority, pProvider);   \
    if (res.getResult() != eRetrievalResultType::eRRT_NoMore)           \
        return res;                                                     \
//    IPSDKBASEPROCESSING_LOG_WARN([eIPSDKBaseProcessingMessage::eErrorCouldNotLaunchGpuProcess] % getClassName())

#define IPSDKCUDA_CHECK_PROCESS_CAN_BE_LAUNCHED_ON_GPU()                                                                                \
    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();                                                         \
                }                                                                                                                       \
            }                                                                                                                           \
        }                                                                                                                               \
    }                                                                                                                                   \


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

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

// ---- Test if a set of images is stored on GPU

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


#define IPSDKCUDA_CHECK_IMAGES_ON_GPU(IMAGES) BOOST_PP_SEQ_FOR_EACH(IPSDKCUDA_APPLY_CHECK_IMAGES_ON_GPU, _, IMAGES)



#endif // __IPSDKIMAGEPROCESSING_CUDAALGORITHMSRCMACROS_H__