/* returns TRUE iff the request was sent on the vc */
static inline int req_uses_vc(const MPID_Request* req, const MPIDI_VC_t *vc)
{
    MPIDI_VC_t *vc1;

    MPIDI_Comm_get_vc(req->comm, req->dev.match.parts.rank, &vc1);
    return vc == vc1;
}

/* returns TRUE iff the vc is part of the comm*/
static inline int is_vc_in_comm(const MPIDI_VC_t *vc, const MPID_Comm *comm)
{
    int i;

    for (i = 0; i < comm->remote_size; ++i) {
        MPIDI_VC_t *vc1;
        MPIDI_Comm_get_vc(comm, i, &vc1);
        if (vc == vc1)
            return TRUE;
    }
    return FALSE;
}

static inline void dequeue_and_set_error(MPID_Request* req,  MPID_Request* prev_req, int error)
{
    /* remove from queue */
    if (recvq_posted_head == req)
        recvq_posted_head = req->dev.next;
    else
        prev_req->dev.next = req->dev.next;
    if (recvq_posted_tail == req)
        recvq_posted_tail = prev_req;

    /* set error and complete */
    req->status.MPI_ERROR = error;
    MPIDI_CH3U_Request_complete(req);
}



#undef FUNCNAME
#define FUNCNAME MPIDU_Complete_posted_with_error
#undef FCNAME
#define FCNAME MPIU_QUOTE(FUNCNAME)
int MPIDI_CH3U_Complete_posted_with_error(MPIDI_VC_t *vc)
{
    int mpi_errno = MPI_SUCCESS;
    MPID_Request *req, *prev_req = NULL;
    MPIDI_STATE_DECL(MPID_STATE_MPIDU_COMPLETE_POSTED_WITH_ERROR);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_COMPLETE_POSTED_WITH_ERROR);

    MPIU_THREAD_CS_ENTER(MSGQUEUE,);

    /* check each req to see if the vc is part of that communicator */
    for (req = recvq_posted_head; req; prev_req = prev_req->dev.next, req = prev_req->dev.next) {

        if (req->dev.match.parts.rank != MPI_ANY_SOURCE) {
            if (req_uses_vc(req, vc)) {
                int error = MPI_SUCCESS;
                MPIU_ERR_SET1(error, MPI_ERR_OTHER, "**comm_fail", "**comm_fail %d", vc->pg_rank);
                dequeue_and_set_error(req, prev_req, error);
            }
        } else {
            /* We need to dequeue all anysources posted in a
               communicator with a failed VC.  We check whether the vc
               is in the communicator by iterating over the comm's VC
               table.  Since this may be expensive, now that we know
               the vc is in comm, we take the opportunity to scan the
               rest of the posted recv queue for other anysources with
               the same communicator.  Note that in the worst case
               this is O(N*M), where N is the number of posted
               requests and M is the number of communicators.  This
               can happen if every req is an anysource and uses a
               different communicator.  We can possibly conditionally
               execute the optimization based on number of comms,
               number of posted requests and communicator size. */
            if (is_vc_in_comm(vc, req->comm)) {
                MPID_Comm *comm = req->comm;
                MPID_Request *as_req, *prev_as_req = prev_req;

                for (as_req = req; as_req; prev_as_req = prev_as_req->dev.next, as_req = prev_as_req->dev.next)
                    if (as_req->comm == comm && as_req->dev.match.parts.rank == MPI_ANY_SOURCE) {
                        int error = MPI_SUCCESS;
                        MPIU_ERR_SET1(error, MPI_ERR_OTHER, "**comm_fail", "**comm_fail %d", vc->pg_rank);
                        dequeue_and_set_error(as_req, prev_as_req, error);
                    }
            }
        }
    }

 fn_exit:
    MPIU_THREAD_CS_EXIT(MSGQUEUE,);

    MPIDI_FUNC_EXIT(MPID_STATE_MPIDU_COMPLETE_POSTED_WITH_ERROR);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}