mpid_win_pscw.c

fortran并行计算包

                win_ptr->_dev.epoch_size = group_ptr->size;
        } else if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_POST) {
                win_ptr->_dev.epoch_type = MPID_EPOTYPE_POSTSTART;
        } else {
                /* --BEGIN ERROR HANDLING-- */
                MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC,
                                        goto fn_fail, "**rmasync");
                /* --END ERROR HANDLING-- */
        }
        win_ptr->start_assert = assert;
        MPIU_Object_add_ref(group_ptr);
        win_ptr->start_group_ptr = group_ptr;
        /**
         * \todo MPI_MODE_NOCHECK might still include POST messages,
         * so the my_sync_begin counter could be incremented. Need to
         * ensure it gets zeroed (appropriately) later...  This is an
         * erroneous condition and needs to be detected and result in
         * reasonable failure.
         */
        if (!(assert & MPI_MODE_NOCHECK)) {
                MPIDU_Progress_spin(win_ptr->_dev.my_sync_begin < group_ptr->size);
                win_ptr->_dev.my_sync_begin = 0;
        }

fn_exit:
        MPIR_Nest_decr();
        MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_START);
        return mpi_errno;

        /* --BEGIN ERROR HANDLING-- */
fn_fail:
        goto fn_exit;
        /* --END ERROR HANDLING-- */
}

/// \cond NOT_REAL_CODE
#undef FUNCNAME
#define FUNCNAME MPID_Win_post
#undef FCNAME
#define FCNAME MPIU_QUOTE(FUNCNAME)
/// \endcond
/**
 * \brief MPI-DCMF glue for MPI_WIN_POST function
 *
 * Begin an exposure epoch on nodes in group. Sends MPID_MSGTYPE_POST
 * message to all nodes in group.
 *
 * \param[in] group_ptr	Group
 * \param[in] assert	Synchronization hints
 * \param[in] win_ptr	Window
 * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from
 *	MPIDU_proto_send.
 *
 * \ref post_design
 */
int MPID_Win_post(MPID_Group *group_ptr, int assert, MPID_Win *win_ptr)
{
        int mpi_errno = MPI_SUCCESS;
        volatile unsigned pending = 0;
        MPIU_THREADPRIV_DECL;
        MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_POST);

        MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_POST);
        MPIU_THREADPRIV_GET;
        MPIR_Nest_incr();
        if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_NONE) {
                /* --BEGIN ERROR HANDLING-- */
                MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC,
                                        goto fn_fail, "**rmasync");
                /* --END ERROR HANDLING-- */
        }
        MPIDU_Spin_lock_free(win_ptr);
        MPID_assert_debug(win_ptr->_dev.my_rma_pends == 0 &&
			win_ptr->_dev.my_get_pends == 0);
        win_ptr->_dev.epoch_size = group_ptr->size;
        win_ptr->_dev.epoch_type = MPID_EPOTYPE_POST;
        win_ptr->_dev.epoch_assert = assert;
        win_ptr->_dev.epoch_rma_ok = 1;
        if (assert & MPI_MODE_NOSTORE) {
                /* TBD: anything to optimize? */
        }
        if (assert & MPI_MODE_NOPUT) {
                /* handled later */
        }
        /**
         * \todo In the NOCHECK case, do we still need to Barrier?
         * How do we detect a mismatch of MPI_MODE_NOCHECK in
         * Win_post/Win_start? If the _post has NOCHECK but the _start
         * did not, the _start will wait forever for the POST messages.
         * One option is to still send POST messages in the NOCHECK
         * case, and just not wait in the _start. The POST message
         * could then send the assert value and allow verification
         * when _start nodes call RMA ops.
         */
        if (!(assert & MPI_MODE_NOCHECK)) {
                mpi_errno = MPIDU_proto_send(win_ptr, group_ptr,
                                MPID_MSGTYPE_POST);
                if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
                /**
                 * \todo In theory, we could just return now without
                 * advance/wait.
                 * MPICH2 says this call "does not block", but is
                 * waiting for messages to send considered blocking in
                 * that context? The receiving nodes (in Win_start)
                 * will not procede with RMA ops until they get this
                 * message, so we need to ensure reasonable progress
                 * between the time we call Win_post and Win_wait.
                 * Also, Win_test is not supposed to block in any
                 * fashion, so it should not wait for the sends to
                 * complete either. It seems that the idea is to have
                 * RMA ops going on while this node is executing code
                 * between Win_post and Win_wait, but that won't
                 * happen unless enough calls are made to advance
                 * during that time...
                 * "need input"...
                 */
                MPIDU_Progress_spin(pending > 0);
        }

fn_exit:
        MPIR_Nest_decr();
        MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_POST);
        return mpi_errno;
        /* --BEGIN ERROR HANDLING-- */
fn_fail:
        goto fn_exit;
        /* --END ERROR HANDLING-- */
}

/// \cond NOT_REAL_CODE
#undef FUNCNAME
#define FUNCNAME MPID_Win_test
#undef FCNAME
#define FCNAME MPIU_QUOTE(FUNCNAME)
/// \endcond
/**
 * \brief MPI-DCMF glue for MPI_WIN_TEST function
 *
 * Test whether the exposure epoch started by MPID_Win_post has ended.
 * If it has ended, clean up and reset window. This routine must call
 * advance at least once, for any code path.
 *
 * \param[in] win_ptr		Window
 * \param[out] flag		Status of synchronization (TRUE = complete)
 * \return MPI_SUCCESS or MPI_ERR_RMA_SYNC.
 *
 * \see mpid_check_post_done
 *
 * \ref post_design
 */
int MPID_Win_test (MPID_Win *win_ptr, int *flag)
{
        int mpi_errno = MPI_SUCCESS;
        MPIU_THREADPRIV_DECL;
        MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_TEST);

        MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_TEST);
        MPIU_THREADPRIV_GET;
        MPIR_Nest_incr();

        if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_POST) {
                /* --BEGIN ERROR HANDLING-- */
                MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC,
                                        goto fn_fail, "**rmasync");
                /* --END ERROR HANDLING-- */
        }
        if ((win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) &&
                                win_ptr->_dev.my_rma_recvs > 0) {
                /* TBD: handled earlier? */
        }
        MPID_Progress_start(&dummy_state);
        *flag = (mpid_check_post_done(win_ptr) != 0);
        MPID_Progress_end(&dummy_state);

fn_exit:
        MPIR_Nest_decr();
        MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_TEST);
        return mpi_errno;
        /* --BEGIN ERROR HANDLING-- */
fn_fail:
        goto fn_exit;
        /* --END ERROR HANDLING-- */
}

/// \cond NOT_REAL_CODE
#undef FUNCNAME
#define FUNCNAME MPID_Win_wait
#undef FCNAME
#define FCNAME MPIU_QUOTE(FUNCNAME)
/// \endcond
/**
 * \brief MPI-DCMF glue for MPI_WIN_WAIT function
 *
 * Wait for exposure epoch started by MPID_Win_post to end.
 *
 * \param[in] win_ptr		Window
 * \return MPI_SUCCESS or MPI_ERR_RMA_SYNC.
 *
 * \see mpid_check_post_done
 *
 * \ref post_design
 */
int MPID_Win_wait(MPID_Win *win_ptr)
{
        int mpi_errno = MPI_SUCCESS;
        MPIU_THREADPRIV_DECL;
        MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_WAIT);

        MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_WAIT);
        MPIU_THREADPRIV_GET;
        MPIR_Nest_incr();

        if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_POST) {
                /* --BEGIN ERROR HANDLING-- */
                MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC,
                                        goto fn_fail, "**rmasync");
                /* --END ERROR HANDLING-- */
        }
        if ((win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) &&
                                win_ptr->_dev.my_rma_recvs > 0) {
                /* TBD: handled earlier? */
        }
        MPID_Progress_start(&dummy_state);
        while (!mpid_check_post_done(win_ptr)) {
                DCMF_CriticalSection_cycle(0);
        }
        MPID_Progress_end(&dummy_state);

fn_exit:
        MPIR_Nest_decr();
        MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_WAIT);
        return mpi_errno;
        /* --BEGIN ERROR HANDLING-- */
fn_fail:
        goto fn_exit;
        /* --END ERROR HANDLING-- */
}