【轉】構建C1000K的伺服器(1) – 基礎

標籤：

原文來自 ideawu 構建C1000K的伺服器(1) – 基礎 

著名的 C10K 問題提出的時候, 正是 2001 年, 到如今 12 年後的 2013 年, C10K 已經不是問題了, 任何一個普通的程式員, 都能利用手邊的語言和庫, 輕鬆地寫出 C10K 的伺服器. 這既得益於軟體的進步, 也得益於硬體效能的提高.

現在, 該是考慮 C1000K, 也就是百萬串連的問題的時候了. 像 Twitter, weibo, Facebook 這些網站, 它們的同時線上使用者有上千萬, 同時又希望訊息能接近即時地推送給使用者, 這就需要伺服器能維持和上千萬使用者的 TCP 網路連接, 雖然可以使用成百上千台伺服器來支撐這麼多使用者, 但如果每台伺服器能支援一百萬串連(C1000K), 那麼只需要十台伺服器.

有很多技術聲稱能解決 C1000K 問題, 例如 Erlang, Java NIO 等等, 不過, 我們應該首先弄明白, 什麼因素限制了 C1000K 問題的解決. 主要是這幾點:

1. 作業系統能否支援百萬串連?
2. 作業系統維持百萬串連需要多少記憶體?
3. 應用程式維持百萬串連需要多少記憶體?
4. 百萬串連的輸送量是否超過了網路限制?

下面來分別對這幾個問題進行分析.

1. 作業系統能否支援百萬串連?

對於絕大部分 Linux 作業系統, 預設情況下確實不支援 C1000K! 因為作業系統包含最大開啟檔案數(Max Open Files)限制, 分為系統全域的, 和進程級的限制.

全域限制

在 Linux 下執行:

cat /proc/sys/fs/file-nr

會列印出類似下面的一行輸出:

51000101747

第三個數字 101747 就是當前系統的全域最大開啟檔案數(Max Open Files), 可以看到, 只有 10 萬, 所以, 在這台伺服器上無法支援 C1000K. 很多系統的這個數值更小, 為了修改這個數值, 用 root 許可權修改 /etc/sysctl.conf 檔案:

fs.file-max = 1020000net.ipv4.ip_conntrack_max = 1020000net.ipv4.netfilter.ip_conntrack_max = 1020000

進程限制

執行:

ulimit -n

輸出:

1024

說明當前 Linux 系統的每一個進程只能最多開啟 1024 個檔案. 為了支援 C1000K, 你同樣需要修改這個限制.

臨時修改

ulimit -n 1020000

不過, 如果你不是 root, 可能不能修改超過 1024, 會報錯:

-bash: ulimit: open files: cannot modify limit: Operation not permitted

永久修改

編輯 /etc/security/limits.conf 檔案, 加入如下行:

# /etc/security/limits.confwork         hard    nofile      1020000work         soft    nofile      1020000

第一列的 work 表示 work 使用者, 你可以填 *, 或者 root. 然後儲存退出, 重新登入伺服器.

注意: Linux 核心源碼中有一個常量(NR_OPEN in /usr/include/linux/fs.h), 限制了最大開啟檔案數, 如 RHEL 5 是 1048576(2^20), 所以, 要想支援 C1000K, 你可能還需要重新編譯核心.

2. 作業系統維持百萬串連需要多少記憶體?

解決了作業系統的參數限制, 接下來就要看看記憶體的佔用情況. 首先, 是作業系統本身維護這些串連的記憶體佔用. 對於 Linux 作業系統, socket(fd) 是一個整數, 所以, 猜想作業系統管理一百萬個串連所佔用的記憶體應該是 4M/8M, 再包括一些管理資訊, 應該會是 100M 左右. 不過, 還有 socket 發送和接收緩衝區所佔用的記憶體沒有分析. 為此, 我寫了最原始的 C 網路程式來驗證:

伺服器

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <arpa/inet.h>#include <netinet/tcp.h>#include <sys/select.h>#define MAX_PORTS 10int main(int argc, char **argv){    struct sockaddr_in addr;    const char *ip = "0.0.0.0";    int opt = 1;    int bufsize;    socklen_t optlen;    int connections = 0;    int base_port = 7000;    if(argc > 2){        base_port = atoi(argv[1]);    }    int server_socks[MAX_PORTS];    for(int i=0; i<MAX_PORTS; i++){        int port = base_port + i;        bzero(&addr, sizeof(addr));        addr.sin_family = AF_INET;        addr.sin_port = htons((short)port);        inet_pton(AF_INET, ip, &addr.sin_addr);        int serv_sock;        if((serv_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){            goto sock_err;        }        if(setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1){            goto sock_err;        }        if(bind(serv_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){            goto sock_err;        }        if(listen(serv_sock, 1024) == -1){            goto sock_err;        }        server_socks[i] = serv_sock;        printf("server listen on port: %d\n", port);    }    //optlen = sizeof(bufsize);    //getsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, &optlen);    //printf("default send/recv buf size: %d\n", bufsize);    while(1){        fd_set readset;        FD_ZERO(&readset);        int maxfd = 0;        for(int i=0; i<MAX_PORTS; i++){            FD_SET(server_socks[i], &readset);            if(server_socks[i] > maxfd){                maxfd = server_socks[i];            }        }        int ret = select(maxfd + 1, &readset, NULL, NULL, NULL);        if(ret < 0){            if(errno == EINTR){                continue;            }else{                printf("select error! %s\n", strerror(errno));                exit(0);            }        }        if(ret > 0){            for(int i=0; i<MAX_PORTS; i++){                if(!FD_ISSET(server_socks[i], &readset)){                    continue;                }                socklen_t addrlen = sizeof(addr);                int sock = accept(server_socks[i], (struct sockaddr *)&addr, &addrlen);                if(sock == -1){                    goto sock_err;                }                connections ++;                printf("connections: %d, fd: %d\n", connections, sock);            }        }    }    return 0;sock_err:    printf("error: %s\n", strerror(errno));    return 0;}

注意, 伺服器監聽了 10 個連接埠, 這是為了測試方便. 因為只有一台用戶端測試機, 最多隻能跟同一個 IP 連接埠建立 30000 多個串連, 所以伺服器監聽了 10 個連接埠, 這樣一台測試機就可以和伺服器之間建立 30 萬個串連了.

用戶端

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <arpa/inet.h>#include <netinet/tcp.h>int main(int argc, char **argv){    if(argc <=  2){        printf("Usage: %s ip port\n", argv[0]);        exit(0);    }    struct sockaddr_in addr;    const char *ip = argv[1];    int base_port = atoi(argv[2]);    int opt = 1;    int bufsize;    socklen_t optlen;    int connections = 0;    bzero(&addr, sizeof(addr));    addr.sin_family = AF_INET;    inet_pton(AF_INET, ip, &addr.sin_addr);    char tmp_data[10];    int index = 0;    while(1){        if(++index >= 10){            index = 0;        }        int port = base_port + index;        printf("connect to %s:%d\n", ip, port);        addr.sin_port = htons((short)port);        int sock;        if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){            goto sock_err;        }        if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){            goto sock_err;        }        connections ++;        printf("connections: %d, fd: %d\n", connections, sock);        if(connections % 10000 == 9999){            printf("press Enter to continue: ");            getchar();        }        usleep(1 * 1000);        /*           bufsize = 5000;           setsockopt(serv_sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));           setsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));         */    }    return 0;sock_err:    printf("error: %s\n", strerror(errno));    return 0;}

我測試 10 萬個串連, 這些串連是閒置, 什麼資料也不發送也不接收. 這時, 進程只佔用了不到 1MB 的記憶體. 但是, 通過程式退出前後的 free 命令對比, 發現作業系統用了 200M(大致)記憶體來維護這 10 萬個串連! 如果是百萬串連的話, 作業系統本身就要佔用 2GB 的記憶體! 也即 2KB 每串連.

可以修改

/proc/sys/net/ipv4/tcp_wmem/proc/sys/net/ipv4/tcp_rmem

來控制 TCP 串連的發送和接收緩衝的大小(多謝 @egmkang).

3. 應用程式維持百萬串連需要多少記憶體?

通過上面的測試代碼, 可以發現, 應用程式維持百萬個閒置串連, 只會佔用作業系統的記憶體, 通過 ps 命令查看可知, 應用程式本身幾乎不佔用記憶體.

4. 百萬串連的輸送量是否超過了網路限制?

假設百萬串連中有 20% 是活躍的, 每個串連每秒傳輸 1KB 的資料, 那麼需要的網路頻寬是 0.2M x 1KB/s x 8 = 1.6Gbps, 要求伺服器至少是萬兆網卡(10Gbps).

總結

Linux 系統需要修改核心參數和系統配置, 才能支援 C1000K. C1000K 的應用要求伺服器至少需要 2GB 記憶體, 如果應用本身還需要記憶體, 這個要求應該是至少 10GB 記憶體. 同時, 網卡應該至少是萬兆網卡.

當然, 這僅僅是理論分析, 實際的應用需要更多的記憶體和 CPU 資源來處理業務資料.

參考:

* http://www.cyberciti.biz/faq/linux-increase-the-maximum-number-of-open-files/
* http://www.lognormal.com/blog/2012/09/27/linux-tcpip-tuning/

【轉】構建C1000K的伺服器(1) – 基礎