|| || || || || || || ||

---

PatRecGenConv2dSep.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_PatRecGenConv2dSep_h
#define Impala_Core_Array_Pattern_PatRecGenConv2dSep_h

#include "Core/Array/Pattern/PatSet.h"
#include "Core/Array/Pattern/PatSetBorder.h"
#include "Core/Array/Pattern/FuncRecGenConv2dSep.h"
#include "Core/Array/CheckBorderSize.h"
#include "Util/TimePlot.h"

#ifdef PX_HORUS_USED
#include "Core/Array/Pattern/PxArrayFunc.h"
#include "Core/Array/Pattern/PxStateTrans.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template <class DstArrayT, class SrcArrayT, class KerArrayT,
          class KerArithT, class PixOpT, class RedOpT>
inline void
PatRecGenConv2dSep(DstArrayT*& dst, SrcArrayT* src, KerArrayT* ker1,
                   KerArrayT* ker2, KerArithT leftBorderNorm,
                   KerArithT rightBorderNorm, KerArithT topBorderNorm,
                   KerArithT bottomBorderNorm, PixOpT& pixOp,
                   RedOpT& redOp, Util::TimePlot* plotter)
{
    int numX = ArrayCW(ker1) / 2 * 2;
    int numY = ArrayCW(ker2) / 2 * 2;
    SrcArrayT* checkedSrc = CheckBorderSize(src, numX, numY);

    if (checkedSrc != src)
    {
        if ((dst != 0) && (dst != src))
            delete dst;
        dst = checkedSrc;
    }
    else
    {
        if (dst != src)
            PatSet(dst, src);
    }

    KerArithT dummy = Element::E1Cast(0, KerArithT());

#ifdef PX_HORUS_USED
    if (!PxRunParallel()) {                         // run sequential
#endif
        if (plotter)
            plotter->SplitTime();
        PatSetBorder(dst, numX, 0, BORDERPROPAGATENORMALIZED, dummy,
                     leftBorderNorm, rightBorderNorm, topBorderNorm,
                     bottomBorderNorm);
        if (plotter)
            plotter->SplitTime();
        FuncRecGenConv2dSepDispatch_H(dst, ker1, pixOp, redOp, rightBorderNorm);
        if (plotter)
            plotter->SplitTime();
        PatSetBorder(dst, 0, numY, BORDERPROPAGATENORMALIZED, dummy,
                     leftBorderNorm, rightBorderNorm, topBorderNorm,
                     bottomBorderNorm);
        if (plotter)
            plotter->SplitTime();
        FuncRecGenConv2dSepDispatch_V(dst, ker2, pixOp, redOp, bottomBorderNorm,
                                      false);

#ifdef PX_HORUS_USED
    } else {                                        // run parallel
        int oldXCPUs = PxXCPUs();
        int oldYCPUs = PxYCPUs();
        int oldZCPUs = PxZCPUs();

        // Initial array redistribution (if needed)

        if (PxYCPUs() != PxNrCPUs()) {
            PxInitSystemGrid(1, PxNrCPUs(), 1);
            int dstState = PxArrayGetState(dst);
            if (dstState == SEQ_PART || dstState == PAR_PART) {
                PxRedistArray(&(dst->mPartArray),1,PxNrCPUs(),1,false);
            }
        } 

        // Compute horizontal

        PxArrayPreStateTrans(dst, PAR_PART, STRONG);
        PatSetBorder(PxArrayPD(dst), numX, 0,
                     BORDERPROPAGATENORMALIZED, dummy, leftBorderNorm,
                     rightBorderNorm, topBorderNorm, bottomBorderNorm);
        FuncRecGenConv2dSepDispatch_H(PxArrayPD(dst), ker1,
                                      pixOp, redOp, rightBorderNorm);

        // Redistribute array

        PxInitSystemGrid(PxNrCPUs(), 1, 1);
        PxRedistArray(&(dst->mPartArray), PxNrCPUs(), 1, 1, false);

        // Compute vertical

        PatSetBorder(PxArrayPD(dst), 0, numY,
                     BORDERPROPAGATENORMALIZED, dummy, leftBorderNorm,
                     rightBorderNorm, topBorderNorm, bottomBorderNorm);
        FuncRecGenConv2dSepDispatch_V(PxArrayPD(dst), ker2, pixOp,
                                      redOp, bottomBorderNorm, false);
        PxArrayPostStateTrans(dst);

        // Undo array redistribution

        PxInitSystemGrid(oldXCPUs, oldYCPUs, oldZCPUs);
        PxRedistArray(&(dst->mPartArray),
                      oldXCPUs, oldYCPUs, oldZCPUs, false);

        if (!PxRunLazyParallel()) {
            PxArrayForceNonDistributed(dst);
        }
    }
#endif
}

} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---