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

---

PxStateTrans.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003-2004, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Frank Seinstra <fjseins@wins.uva.nl>
 */

#ifndef __PxStateTrans_h_
#define __PxStateTrans_h_

#include "Core/Array/Pattern/ArrayFunc.h"
#include "Core/Array/Pattern/FuncSet.h"
#include "Core/Array/Pattern/PxArrayFunc.h"
#include "Core/Array/Pattern/PxSystem.h"
#include "Core/Array/Pattern/PxDistribution.h"
#include "Core/Array/Pattern/PxPartition.h"

namespace Impala
{
namespace Core
{
namespace Array
{

// This is used in Array2dTem, so easier when in this namespace
enum states   { EMPTY,      // q_0 = < none,     none,     none >
                SEQ_CREAT,  // q_1 = < created,  none,     none >
                SEQ_VALID,  // q_2 = < valid,    none,     none >
                DYING,      // q_3 = < invalid,  none,     none >
                SEQ_PART,   // q_4 = < valid,    valid,    partial >
                SEQ_FULL,   // q_5 = < valid,    valid,    full >
                PAR_PART,   // q_6 = < invalid,  valid,    partial >
                PAR_FULL,   // q_7 = < invalid,  valid,    full >
                NOT_REDUCED // q_8 = < invalid,  invalid,  not-reduced >
};

namespace Pattern
{


/*** Declarations *****************************************************/


enum tr_force { WEAK, STRONG }; // 'strength' of state transition

int  prnt = 0;                  // output state transitions?


/**********************************************************************/

template<class ArrayT>
inline void
PxArrayPreStateTrans(ArrayT* a, int goState, int force)
{
    int aState = a->mState;

    /*** Initialize data distribution ***/

    PxInitDistribution(ArrayCW(a), ArrayCH(a), ArrayCD(a),
                       PxXCPUs(), PxYCPUs(), PxZCPUs());

    /*** Do nothing, if nothing to do ***/

    if ((goState==SEQ_VALID && force==WEAK &&
                            (aState==SEQ_PART || aState==SEQ_FULL)) ||
        (goState==SEQ_VALID && force==STRONG &&
                            (aState==SEQ_CREAT || aState==SEQ_VALID)) ||
        (goState==PAR_PART && (aState==SEQ_PART || aState==PAR_PART)) ||
        (goState==PAR_FULL && (aState==SEQ_FULL || aState==PAR_FULL))) {
        if (prnt) PX_COUT << "PASS: state = " << aState << PX_ENDL;
        return;
    } else if (aState==DYING || aState==NOT_REDUCED) {
        PX_COUT << "ERROR: state = DYING or NOT_REDUCED" << PX_ENDL;
        PxAbortSystem();
        return;
    }

    /*** Initial step in two-phase state transition (if needed) ***/

    if (aState==PAR_FULL && (goState==SEQ_VALID || goState==PAR_PART)) {
        if (prnt) PX_COUT << "LOCAL-2-GLOBAL COPY" << PX_ENDL;
        FuncSet(a, PxArrayPD(a), 0,0, ArrayW(a),ArrayH(a), 0,0);
        a->mState = SEQ_FULL;
        aState = SEQ_FULL;

    } else if (aState==PAR_PART &&
                            (goState==SEQ_VALID || goState==PAR_FULL)) {
        if (prnt) PX_COUT << "GATHER" << PX_ENDL;
        PxGatherArray(a, PxArrayPD(a), PxRootCPU(), PX_SBT, false);
        a->mState = SEQ_PART;
        aState = SEQ_PART;
    }

    if (goState==SEQ_VALID && force==WEAK) {
        return;
    }

    /*** Remove current partial array, if it exists ***/

    if (PxArrayPD(a) != 0) {
        if (prnt) PX_COUT << "DELETE LOCAL" << PX_ENDL;
        PxArrayDeletePD(a);
        if (goState==SEQ_VALID) {
            a->mState = SEQ_VALID;
            return;
        }
    }

    /*** CreatePart and Scatter array data ***/

    if (goState==PAR_PART &&
        (aState==SEQ_CREAT || aState==SEQ_VALID || aState==SEQ_FULL))  {
        if (prnt) PX_COUT << "CREATE LOCAL (PARTIAL)" << PX_ENDL;
        PxArrayCreatePD(a, PxLclWidth(PxMyCPU()),
                        PxLclHeight(PxMyCPU()), PxLclDepth(PxMyCPU()),
                        ArrayBW(a), ArrayBH(a), ArrayBD(a));
        if (force==STRONG && (aState==SEQ_VALID || aState==SEQ_FULL)) {
            if (prnt) PX_COUT << "SCATTER" << PX_ENDL;
            PxScatterArray(a, PxArrayPD(a), PxRootCPU(), PX_SBT, false);
        }
        a->mState = SEQ_PART;
        return;

    /*** CreateFull and Broadcast array data ***/

    } else if (goState==PAR_FULL &&
        (aState==SEQ_CREAT || aState==SEQ_VALID || aState==SEQ_PART)) {
        if (prnt) PX_COUT << "CREATE LOCAL (FULL)" << PX_ENDL;
        PxArrayCreatePD(a, ArrayCW(a), ArrayCH(a), ArrayCD(a),
                        ArrayBW(a), ArrayBH(a), ArrayBD(a));
        if (PxMyCPU() == PxRootCPU()) {
            if (prnt) PX_COUT << "GLOBAL-2-LOCAL COPY" << PX_ENDL;
            FuncSet(PxArrayPD(a),
                    a, 0, 0, ArrayW(a), ArrayH(a), 0, 0);
        }
        if (force==STRONG && (aState==SEQ_VALID || aState==SEQ_PART)) {
            if (prnt) PX_COUT << "BROADCAST" << PX_ENDL;
            PxBcastArray(PxArrayPD(a), PxRootCPU(), PX_SBT, false);
        }
        a->mState = SEQ_FULL;
        return;
    }
}


template<class ArrayT>
inline void
PxArrayPostStateTrans(ArrayT* a)
{
    if (a->mState == SEQ_PART) {
        a->mState = PAR_PART;
    } else if (a->mState == SEQ_FULL) {
        a->mState = PAR_FULL;
    }
}


template<class ArrayT>
inline void
PxArrayForceNonDistributed(ArrayT* a)
{
    PxArrayPreStateTrans(a, SEQ_VALID, STRONG);
    a->mState = SEQ_VALID;
}


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

#endif /* __PxStateTrans_h_ */

---