（P18）socket編程（十三）

文章目錄

1.select vs poll

select限制
（1）一個進程能打開的最大文件描述符的個數是有限的
（2）FD_SETSIZE(fd_set)
poll限制，poll只有select的第一個限制
（1）一個進程能打開的最大文件描述符的個數是有限的
最大文件描述符的個數除了使用ulimit -n number來設置，還和什麼相關？
系統所有打開的最大文件描述符的個數也是有限的，跟內存大小有關

cat /proc/sys/fs/file-max

因爲當前內存是512M，所以系統可以打開的最大文件描述符的個數爲5萬。若是1G，則是10萬左右，10G就是百萬。

select和poll的效率不高共同點：
內核要遍歷所有文件描述符，直到找到發生事件的文件描述符

2.epoll使用

#include <sys/epoll.h>

int epoll_create(int size);創建一個epoll實例，size不是最大併發數，size僅僅代表內部所創建的hash表的大小
int epoll_create1(int flags);最新的，而且fd的數量已經由紅黑樹來控制
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);將一個fd添加到epoll來管理
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);等待事件

eg：epoll這塊測試代碼用c++編寫
服務端代碼：NetworkProgramming-master (1)\LinuxNetworkProgramming\P18epollsrv.cpp

//
// Created by jxq on 19-8-7.
//

// socket編程 13 epoll 模型

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <poll.h>
#include <vector>
#include <sys/stat.h>
#include <fcntl.h>
#include <algorithm>


using namespace std;

typedef vector<struct epoll_event> EventList;//vector：動態數組

struct packet
{
    int len;
    char buf[1024];
};

#define ERR_EXIT(m) \
        do  \
        {   \
            perror(m);  \
            exit(EXIT_FAILURE); \
        } while(0);

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;   // 剩餘字節數
    ssize_t nread;
    char *bufp = (char*) buf;

    while (nleft > 0)
    {
        nread = read(fd, bufp, nleft);
        if (nread < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return  -1;
        } else if (nread == 0)
        {
            return count - nleft;
        }

        bufp += nread;
        nleft -= nread;
    }
    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return -1;
        }
        else if (nwritten == 0)
        {
            continue;
        }
        bufp += nwritten;
        nleft -= nwritten;
    }
    return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK); // 查看傳入消息
        if (ret == -1 && errno == EINTR)
        {
            continue;
        }
        return ret;
    }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;
    char *bufp = (char*)buf;    // 當前指針位置
    int nleft = maxline;
    while (1)
    {
        ret = recv_peek(sockfd, buf, nleft);
        if (ret < 0)
        {
            return ret;
        }
        else if (ret == 0)
        {
            return ret;
        }
        nread = ret;
        int i;
        for (i = 0; i < nread; i++)
        {
            if (bufp[i] == '\n')
            {
                ret = readn(sockfd, bufp, i+1);
                if (ret != i+1)
                {
                    exit(EXIT_FAILURE);
                }
                return ret;
            }
        }
        if (nread > nleft)
        {
            exit(EXIT_FAILURE);
        }
        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
        {
            exit(EXIT_FAILURE);
        }
        bufp += nread;
    }
    return -1;
}

void echo_srv(int connfd)
{
    char recvbuf[1024];
    // struct packet recvbuf;
    int n;
    while (1)
    {
        memset(recvbuf, 0, sizeof recvbuf);
        int ret = readline(connfd, recvbuf, 1024);
        if (ret == -1)
        {
            ERR_EXIT("readline");
        }
        if (ret == 0)
        {
            printf("client close\n");
            break;
        }

        fputs(recvbuf, stdout);
        writen(connfd, recvbuf, strlen(recvbuf));
    }

}

void activate_nonblock(int fd)
{
    int ret;
    int flags = fcntl(fd, F_GETFL);
    if(flags == -1)
        ERR_EXIT("fcntl");
    flags |= O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if(ret == -1)
        ERR_EXIT("fcntl");
}

int main(int argc, char** argv) {
    // 1. 創建套接字
    int listenfd;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        ERR_EXIT("socket");
    }

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof servaddr);
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    int on = 1;
    // 確保time_wait狀態下同一端口仍可使用
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) < 0) {
        ERR_EXIT("setsockopt");
    }

    // 3. 綁定套接字地址
    if (bind(listenfd, (struct sockaddr *) &servaddr, sizeof servaddr) < 0) {
        ERR_EXIT("bind");
    }
    // 4. 等待連接請求狀態
    if (listen(listenfd, SOMAXCONN) < 0) {
        ERR_EXIT("listen");
    }
    // 5. 允許連接
    struct sockaddr_in peeraddr;
    socklen_t peerlen;


    // 6. 數據交換
    int nready;
    int connfd;
    int i;
    vector<int> clients;//保存客戶端的已連接套接字
    int epollfd;
    //EPOLL_CLOEXEC含義：該進程被替換的時候，文件描述會被關閉
    epollfd = epoll_create1(EPOLL_CLOEXEC); // 創建一個epoll的實例

    struct epoll_event event;
    //typedef union epoll_data{...};
    //struct epoll_enent{_uint32_t enents; epoll_data data};
    //感興趣的fd是監聽listenfd
    event.data.fd = listenfd;//data是一個聯合體，共用體，共用體的大小是8個字節
    event.events = EPOLLIN | EPOLLET;//listenfd感興趣的事件：EPOLLIN，是否事件到來，EPOLLET表示邊沿方式觸發
    epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);//（epoll實例句柄，操作方式，將fd添加至epoll來管理，該fd感興趣的事件）

    EventList events(16);//events數組的初始值爲16

    while (1)
    {
        //epoll_wait檢測哪一些IO產生了事件，（epoll實例句柄，哪些事件產生了感興趣的事件，能夠返回的最大事件個數，超時時間）
        // 等侍註冊在epfd上的socket fd的事件的發生，如果發生則將發生的sokct fd和事件類型放入到events數組中
        //events.begin()是一個迭代器，可以看成一個指針，*events.begin()：取數組第一個元素，類型就是struct epoll_event
        //&*events.begin()：動態數組的首地址
        //不直接使用vents.begin()，是因爲他類型是一個迭代器，類型不匹配，編譯不通過，取&*就等價於struct epoll_event*
        nready = epoll_wait(epollfd, &*events.begin(), static_cast<int>(events.size()), -1);    // -1：一直等待，直到有事件產生

        if (nready == -1)
        {
            if (errno == EINTR)
            {
                continue;
            }
            ERR_EXIT("epoll_wait");
        }

        if (nready == 0)
        {
            continue;
        }

        //nready：等待到的事件個數
        if ((size_t)nready == events.size())//說明容器容量不夠大，需要調整容器容量的大小
        {
            events.resize(events.size()*2);
        }

        //返回的事件，保存在&*events.begin()中
        for (i = 0; i < nready; ++i)//返回了nready個事件
        {
            //epoll效率比select和poll高的核心：返回的事件保存在events中，通過events可以找到fd，也就是說這些fd產生了事件
            //就不需要遍歷哪些socket在某個集合中產生了可讀事件，因爲events指示的fd已經產生了事件
            if (events[i].data.fd == listenfd)//listenfd產生了可讀事件
            {
                peerlen = sizeof(peeraddr);
                connfd = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
                if (connfd == -1)
                {
                    ERR_EXIT("accept");
                }
                printf("id = %s, ", inet_ntoa(peeraddr.sin_addr));
                printf("port = %d\n", ntohs(peeraddr.sin_port));
                clients.push_back(connfd);
                activate_nonblock(connfd);

                event.data.fd = connfd;
                event.events = EPOLLIN | EPOLLET;
                epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event);

                //下一次epoll_wait就有可能產生監聽fd和連接fd產生可讀事件

            }//只需要判斷events產生了哪些事件 ，可讀，可寫？
            //不需要遍歷哪個fd產生了事件，因爲events[i].data.fd中的fd就是產生事件的套接字
            else if (events[i].events & EPOLLIN)//已連接fd產生了可讀事件
            {
                connfd = events[i].data.fd;//取出已連接fd
                if (connfd < 0)
                {
                    continue;
                }
                char recvbuf[1024];
                int ret = readline(connfd, recvbuf, sizeof(recvbuf));
                if (ret == -1)
                {
                    ERR_EXIT("readline");
                }
                if (ret == 0)//表示對方關閉
                {
                    printf("client close\n");
                    close(connfd);

                    event = events[i];//對方關閉，要將該events[i]從epollfd中刪除
                    epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
                    //刪除已連接fd
                    clients.erase(std:remove(clients.begin(), clients.end(), connfd),clients.end());
                    // clients.erase(
                    //         remove_if(clients.begin(), clients.end(), [connfd](int n){return n == connfd;}),
                    //         clients.end());
                }
                fputs(recvbuf, stdout);
                writen(connfd, recvbuf, strlen(recvbuf));
            }
        }

    }
    // 7. 斷開連接
    close(listenfd);
    return 0;
}

客戶端代碼：NetworkProgramming-master (1)\LinuxNetworkProgramming\P17\P17echocli.c
測試：
客戶端

服務端
總共1024個fd，爲什麼只有1019個fd？
0 1 2 3(監聽fd)，4(epollfd的句柄)，所以最多連接1019個fd
Makefile

.PHONY:clean all
CC=gcc
CFLAGS=-Wall -g
BIN=echosrv echocli nofile_limit contest pollsrv epollsrv
all:$(BIN)
%.o:%.c
	$(CC) $(CFLAGS) -c $< -o $@
%.o:%.cpp
	g++ $(CFLAGS) -c $< -o $@
epollsrv:epollsrv.o
	g++ $(CFLAGS) -c $^ -o $@
clean:
	rm -f *.o $(BIN)

3.epoll與select、poll的區別

（1）相比於select與poll、epoll最大的好處在於他不會隨着監聽fd數目的增長而降低效率
（2）內核中的select與poll的實現是採用輪詢來處理的，輪詢的fd數目越多，自然耗時越多
（3）epoll的實現是基於回調的，如果fd有期望的事件發生就通過回調函數將其加入epoll就緒隊列中，也就是說它只關心活躍的fd，與fd數目無關
epoll_wait返回的事件就已經指出了哪一個fd發生了可讀或者可寫的事件，所以不用在應用層遍歷fd
（4）內核/用戶空間內存拷貝問題，如何讓內核把fd消息通知給用戶空間呢？
在這個問題上，select/poll採用了內存拷貝方法，而epoll採用了共享內存的方式。
（5）epoll不僅會告訴應用程序有I/O事件到來，還會告訴應用程序相關的信息，這些信息是應用程序填充的(填充指的是epoll_ctrl填充的)，因此根據這些信息，應用程序就能直接定位到事件，而不必遍歷整個fd集合
epoll少了2次的遍歷
第（3）和第（4），epoll比poll和select效率高的原因

4.epoll模式：EPOLLLT，EPOLLET

EPOLLLT
（1）level trigger電平觸發，水平觸發
（2）完全靠kernel epoll驅動，應用程序只需要處理從epoll_wait返回的fds （就緒隊列的描述符），這些fds，我們認爲它們處於就緒狀態
EPOLLET
（1）edege trigger邊緣觸發，效率更高
（2）此模式下，系統僅僅通知應用程序哪些fds變成了就緒狀態，一旦fd變成就緒狀態 （只通知一次），epoll將不再關注這個fd的任何狀態信息，（從epoll隊列移除）直到應用程序通過讀寫操作觸發EAGAIN狀態，epoll認爲這個fd又變爲了空閒狀態，那麼epoll又重新關注這個fd的狀態變化（重新加入epoll隊列）
（3）隨着epoll_wait的返回，隊列中的fds是在減少的，所以在大併發的系統中，EPOLLET更有優勢。
但是對程序員的要求也更高。
（4）EPOLLET只關注fd從空閒到就緒態的狀態送觸發的事件，返回相應的事件
若數據沒有處理完，就調用epoll_wait的話，就會出問題，假如對方發送過來2K數據，讀取的時候只讀取了1K的數據，然後調用epoll_wait重新監聽狀態，此時就沒有辦法監聽狀態了，會一直阻塞，因爲他是邊緣觸發：從空閒到就緒狀態的觸發，此時內核中雖然還有數據，他也不再觸發可讀事件，而LT模式只要緩衝區的事件沒有讀取完，就會觸發，所以LT觸發的次數更多，那麼他的效率就會下降（下降的效率也不是特別多）
剩下的1K怎麼讀取呢？
這就需要應用層維護一個就緒隊列，而水平觸發方式的方式是由系統內部維護的
ET模式需要維護一個就緒隊列，如果不維護，那麼處理很容易出差錯，若沒有讀取完全的話，直接調用epoll_wait函數就會一直阻塞了，就不再觸發了。
或者讀完了，觸發一個EAGAIN，表示全部讀完了，前提是將fd設置爲非阻塞模式，epoll認爲這個fd變成了空閒狀態了，此時可以重新關心fd的變化(即重新加入epoll隊列)，如果有新事件到來的時候，他將不再阻塞

（P18）socket編程（十三）

文章目錄

1.select vs poll

2.epoll使用

3.epoll與select、poll的區別

4.epoll模式：EPOLLLT，EPOLLET

（P20）socket編程（十五）

Linux內核的組成部分

線程棧和進程棧

（P18）socket編程（十三）

（P17）socket編程（十二）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結