* zostawić w spokoju ''.revents'' – tam pojawi się informacja o tym co wystąpiło - w pętli wywoływać funkcję ''poll(…)''. \\ ostatni argument funkcji ''poll'' to maksymalny czas oczekiwania; aby funkcja czekała bez limitu, należy podać tam dowolną ujemną wartość - sprawdzać który deskryptor jest gotowy przeglądając pola ''.revents'' Funkcja ''poll'', struktura ''pollfd'' i stałe ''POLL…'' są w pliku nagłówkowym ''#include ''

pollfd pfds[COUNT]{};                                          ─┐
pfds[0].fd = STDIN_FILENO;   pfds[2].fd = cliSock1;             │
pfds[0].events = POLLIN;     pfds[2].events = POLLIN;           ├─ (1)
pfds[1].fd = serverSock;     pfds[3].fd = cliSock2;             │
pfds[1].events = POLLIN;     pfds[3].events = POLLIN|POLLOUT;  ─┘
...                          ...

while(1){
    int ile_gotowych = poll(pfds, liczbaStruktur, -1);         ═╾─ (2)

    if(pfds[0].revents & POLLIN) readingFromStdin();           ─┐
    if(pfds[1].revents & POLLIN) acceptingNewClient();          │
    for(int i = 2; i < liczbaStruktur; ++i){                    │
        if(pfds[i].revents & POLLIN)                            ├─ (3)
            readFromClient(pfds[i].fd);                         │
        if(pfds[i].revents & POLLOUT)                           │
            writeToClient(pfds[i].fd);                         ─┘
    }
}

~~Zadanie.#~~ Powtórz Zadanie 1, ale tym razem jako jednowątkowy program wykorzystujący ''poll''. \\ (Możesz skorzystać z {{:sk2:tcp_client_template.cpp|przykładowego kodu klienta}}) ===== epoll ===== Mechanizm działania ''epoll'' jest inny niż ''select'' czy ''poll''. - Wpierw programista musi stworzyć interfejs do monitorowania plików funkcją ''epoll_create'' lub ''epoll_create1'' – interfejs trafia do tablicy deskryptorów plików (analogicznie do ''open()'', ''pipe()'' czy ''socket()''). Po skończonej pracy zamyka się go podobnie jak każdy plik – funkcją ''close''. - Lista monitorowanych deskryptorów jest przechowywana w pamięci jądra systemu operacyjnego – aby ją uzupełnić, należy użyć funkcji ''epoll_ctl''. Pozwala ona powiązać deskryptor z listą zdarzeń na które oczekuje program oraz dowolnymi danymi mieszczącymi się w unii ''epoll_data_t''. - Funkcja czekająca na zdarzenia – ''epoll_wait'' – przyjmuje jako argumenty tylko deskryptor utworzony przez ''epoll_create'', tablicę zdarzeń do wypełnienia i czas oczekiwania (-1 = nieskończoność). \\ - ''epoll_wait'' nie przekazuje numerów gotowych deskryptorów – przekazuje tylko rodzaj zdarzenia i powiązane z nim wcześniej dane. Funkcje ''epoll_…'', struktura ''epoll_event'' i stałe ''EPOLL…'' są w pliku nagłówkowym ''#include ''

struct Client {
    int fd;
    char *partialDataReceived, *dataQueuedToSend;
} *clients;
void receiveFromCli(Client *c);
void sendQueuedData(Client *c);

...

  int epollDescr = epoll_create1(0);                                   ═╾─ (1)

  epoll_event ee[2];                                                   ─┐
  ee[0].events = EPOLLIN;                                               │
  ee[0].data.u32 = -1;                                                  ├─ (2)
  epoll_ctl(epollDescr, EPOLL_CTL_ADD, STDIN_FILENO, &ee[0]);           │
  ee[0].data.u32 = -2;                                                  │
  epoll_ctl(epollDescr, EPOLL_CTL_ADD, serverSock, &ee[0]);            ─┘ 

  while (1) {
      int ile_gotowych = epoll_wait(epollDescr, ee, 2, -1);            ═╾─ (3)

      for (int i = 0; i < ile_gotowych; ++i) {                         ─┐
          if (ee[i].data.u32 == -1)                                     │
              readingFromStdin();                                       │
          else if (ee[i].data.u32 == -2) {                              │
              int cliFd = accept(serverSock, 0, 0);                     │
              int cliId = getFreeClientId();                            │
              clients[cliId] = {.fd = cliFd};                           │
              ee[0].events = EPOLLIN;                               ┐   │
              ee[0].data.u32 = cliId;                               ├(2)├─ (4)
              epoll_ctl(epollDescr, EPOLL_CTL_ADD, cliFd, &ee[0]);  ┘   │
          } else {                                                      │
              if (ee[i].events & EPOLLIN)                               │
                  receiveFromCli(&clients[ee[i].data.u32]);             │
              if (ee[i].events & EPOLLOUT)                              │
                  sendQueuedData(&clients[ee[i].data.u32]);             │
          }                                                             │
      }                                                                ─┘
  }

++++Przykład użycia pola ''.data.ptr''|

struct Handler {
    virtual void handle(epoll_event &ee) = 0;
    virtual ~Handler() {}
};

struct Client;
std::set<Client *> clients;
struct Client : public Handler {
    char *partialDataReceived, *dataQueuedToSend;
    int epollDescr, fd;
    Client(int epollDescr, int fd) : epollDescr(epollDescr), fd(fd) {
        epoll_event ee{.events = EPOLLIN, .data = {.ptr = this}};
        epoll_ctl(epollDescr, EPOLL_CTL_ADD, fd, &ee);
        clients.insert(this);
    }
    ~Client() {
        close(fd);
        ...
    }
    void receive(epoll_event &ee);
    void sendQueuedData();
    void handle(epoll_event &ee) {
        if (ee.events & EPOLLIN)
            receive(ee);
        if (ee.events & EPOLLOUT)
            sendQueuedData();
    }
    ...
};
struct Server : public Handler {
    int epollDescr, serverSock;
    Server(int epollDescr, uint16_t port) : epollDescr(epollDescr) {
        serverSock = ...
        ...
        epoll_event ee{.events = EPOLLIN, .data = {.ptr = this}};
        epoll_ctl(epollDescr, EPOLL_CTL_ADD, serverSock, &ee);
    }
    ~Server();
    void handle(epoll_event &) {
        int cliFd = accept(serverSock, 0, 0);
        new Client(epollDescr, cliFd);
    }
};

int main() {
    ...
    int epollDescr = epoll_create1(0);
    Server srv(epollDescr, port);
    while (1) {
        epoll_event ee;
        epoll_wait(epollDescr, &ee, 1, -1);
        ((Handler *)ee.data.ptr)->handle(ee);
    }
}

++++ ~~Zadanie.#~~ Powtórz Zadanie 1, ale tym razem jako jednowątkowy program wykorzystujący mechanizm epoll. \\ (Możesz skorzystać z {{:sk2:tcp_client_template.cpp|przykładowego kodu klienta}}) ~~Zadanie.#~~ Napisz jednowątkowy serwer czatu używając ''poll'' lub ''epoll_wait''. \\ (Możesz skorzystać z {{:sk2:tcp_server_template.cpp|przykładowego kodu serwera}})