Exemple #1
0
static ucs_status_t test_poll_wait(ucp_worker_h ucp_worker)
{
    int ret = -1;
    ucs_status_t status;
    int epoll_fd_local = 0, epoll_fd = 0;
    struct epoll_event ev;
    ev.data.u64 = 0;

    status = ucp_worker_get_efd(ucp_worker, &epoll_fd);
    if (status != UCS_OK) {
        goto err;
    }
    /* It is recommended to copy original fd */
    epoll_fd_local = epoll_create(1);

    ev.data.fd = epoll_fd;
    ev.events = EPOLLIN;
    if (epoll_ctl(epoll_fd_local, EPOLL_CTL_ADD, epoll_fd, &ev) < 0) {
        fprintf(stderr, "Couldn't add original socket %d to the "
                "new epoll: %m\n", epoll_fd);
        goto err_fd;
    }
    /* Need to prepare ucp_worker before epoll_wait */
    status = ucp_worker_arm(ucp_worker);
    if (status != UCS_OK) {
        goto err_fd;
    }

    do {
        ret = epoll_wait(epoll_fd_local, &ev, 1, -1);
    } while ((ret == -1) && (errno == EINTR));

    ret = UCS_OK;

err_fd:
    close(epoll_fd_local);

err:
    return ret;
}
Exemple #2
0
int progress(int server, int msg_size)
{
    int flag = 1;
    int recvd = 0, sent = 0;
    struct ucx_context *sreq = NULL, *rreq = NULL;
    struct epoll_event events[2];
    int ret;

    if( server ){
        sreq = launch_send(msg_size);
        if( !sreq ){
            /* inline send */
            sent = 1;
        }
    }

    progress_calls++;

    while (flag) {
        int i;
        ucs_status_t status;

        status = ucp_worker_arm(ucp_worker);

        if (status == UCS_ERR_BUSY) { /* some events are arrived already */
            struct ucx_context *tmp;
            ucp_worker_progress(ucp_worker);

            progress_count++;

            tmp = launch_recv();
            rreq = (rreq) ? rreq : tmp;
            ret = 0;
            goto progress;
        } else if ( UCS_OK != status ){
            abort();
        }

        ret = epoll_wait(epoll_fd_local, events, 2, -1);
        if ( 0 > ret ) {
            if (errno == EINTR) {
                continue;
            } else {
                abort();
            }
        }

        ucp_worker_progress(ucp_worker);

        progress_count++;

        for(i=0; i<ret; i++){
            if( events[i].data.fd == epoll_fd){
                struct ucx_context *tmp;
                tmp = launch_recv();
                rreq = (rreq) ? rreq : tmp;
                continue;
            }

            if( events[i].data.fd == signal_pipe[0]){
                char buf;
                read(signal_pipe[0], &buf, sizeof(buf));
                continue;
            }
        }

progress:
        if( sreq ){
            if( sreq->completed ){
                if( !same_buf ){
                    free(sreq->buf);
                }
                sreq->completed = 0;
                ucp_request_release(sreq);
                sreq = NULL;
                sent = 1;
            }
        }
        if( rreq ){
            if( rreq->completed ){
                if( !same_buf ) {
                    free(rreq->buf);
                }
                rreq->completed = 0;
                ucp_request_release(rreq);
                rreq = NULL;

                recvd = 1;
                if( !server ){
                    sreq = launch_send(msg_size);
                    if( !sreq ){
                        /* inline send */
                        sent = 1;
                    }
                }
            }
        }

        if( recvd && sent ){
            flag = 0;
        }

        if( sreq || rreq ){
            activate_progress();
        }
    }
}