POSIX
Input / Output multiplexing

introduzione

Sondaggio

In questo esempio creiamo una coppia di socket connessi e inviamo 4 stringhe da una all'altra e stampiamo le stringhe ricevute sulla console. Nota che il numero di volte che chiameremo send potrebbe non essere uguale al numero di volte che chiamiamo recv

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>

#define BUFSIZE 512

int main()
{    
    #define CKERR(msg) {if(ret < 0) { perror(msg); \
        close(sockp[0]); close(sockp[1]); exit(EXIT_FAILURE); } }
    const char* strs_to_write[] = {"hello ", "from ", "other ", "side "};
    
    int sockp[2] = {-1, -1};
    ssize_t ret = socketpair (AF_UNIX, SOCK_STREAM, 0, sockp);
    CKERR("Socket pair creation error")
    
    struct pollfd pfds[2];
    for(int i=0; i<2; ++i) {
        pfds[i] = (struct pollfd){sockp[i], POLLIN|POLLOUT, 0};
        fcntl(sockp[i], F_SETFL|O_NONBLOCK); // nonblocking fds are
                // literally mandatory for IO multiplexing; non-portable
    }
    char buf[BUFSIZE];
    
    size_t snt = 0, msgs = sizeof(strs_to_write)/sizeof(char*);
    while(1) {
        int ret = poll(pfds,
            2 /*length of pollfd array*/,
            5 /*milliseconds to wait*/);
        CKERR("Poll error")

        if (pfds[0].revents & POLLOUT && snt < msgs) {
            // Checking POLLOUT before writing to ensure there is space
            // available in socket's kernel buffer to write, otherwise we
            // may face EWOULDBLOCK / EAGAIN error
            ssize_t ret = send(sockp[0], strs_to_write[snt], strlen(strs_to_write[snt]), 0);
            if(++snt >= msgs)
                close(sockp[0]);
            CKERR("send error")
            if (ret == 0) {
                puts("Connection closed");
                break;
            }
            if (ret > 0) {
                // assuming that all bytes were written
                // if ret != %sent bytes number%, send other bytes later
            }
        }
        if (pfds[1].revents & POLLIN) {
            // There is something to read
            ssize_t ret = recv(sockp[1], buf, BUFSIZE, 0);
            CKERR("receive error")
            if (ret == 0) {
                puts("Connection closed");
                break;
            }
            if (ret > 0) {
                printf("received str: %.*s\n", (int)ret, buf);
            }
        }

    }
    close(sockp[1]);
    return EXIT_SUCCESS;
}

Selezionare

Select è un altro modo di fare il multiplexing I / O. Uno dei suoi vantaggi è un'esistenza nell'API di winsock. Inoltre, su Linux, select () modifica il timeout per riflettere la quantità di tempo non dormita; la maggior parte delle altre implementazioni non lo fa. (POSIX.1 consente entrambi i comportamenti).

Sia il sondaggio che la selezione hanno alternative ppoll e pselect, che consentono di gestire i segnali in entrata durante l'attesa dell'evento. Entrambi diventano lenti con un'enorme quantità di descrittori di file (cento e più), quindi sarebbe saggio scegliere una chiamata specifica per piattaforma, ad esempio epoll su Linux e kqueue su FreeBSD. O passare a API asincrone (POSIX aio ad esempio o qualcosa di specifico come IO Completion Ports).

Seleziona la chiamata ha il seguente prototipo:

int select(int nfds, fd_set *readfds, fd_set *writefds,
       fd_set *exceptfds, struct timeval *timeout);

fd_set è una matrice di maschera di bit di descrittori di file,

nfds è il numero massimo di tutti i descrittori di file nel set + 1.

Snippet di lavorare con select:

fd_set active_fd_set, read_fd_set;
FD_ZERO (&active_fd_set); // set fd_set to zeros
FD_SET (sock, &active_fd_set); // add sock to the set
// # define FD_SETSIZE sock + 1
while (1) {
    /* Block until input arrives on one or more active sockets. */
    read_fd_set = active_fd_set; // read_fd_set gets overriden each time
    if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0) {
        // handle error
    }
    // Service all file descriptors with input pending.
    for (i = 0; i < FD_SETSIZE; ++i) {
        if (FD_ISSET (i, &read_fd_set)) {
            // there is data for i
    }
}

Si noti che sulla maggior parte delle implementazioni POSIX i descrittori di file associati ai file su disco stanno bloccando. Quindi scrivere in un file, anche se questo file è stato impostato in writefds , bloccherebbe fino a che tutti i byte non saranno scaricati sul disco