最近有朋友在面試的時候被問了select 和epoll效率差的原因，和一般人一樣，大部分都會回答select是輪詢、epoll是觸發式的，所以效率高。這個答案聽上去很完美，大致也說出了二者的主要區別。
今天閒來無事，翻看了下核心程式碼，結合核心程式碼和大家分享下我的觀點。

一、連線數

我本人也曾經在專案中用過select和epoll,對於select，感觸最深的是linux下select最大數目限制(windows 下似乎沒有限制)，每個程序的select最多能處理FD_SETSIZE個FD(檔案控制代碼)，
如果要處理超過1024個控制代碼，只能採用多程序了。
常見的使用slect的多程序模型是這樣的： 一個程序專門accept，成功後將fd通過unix socket傳遞給子程序處理，父程序可以根據子程序負載分派。曾經用過1個父程序+4個子程序 承載了超過4000個的負載。
這種模型在我們當時的業務執行的非常好。epoll在連線數方面沒有限制，當然可能需要使用者呼叫API重現設定程序的資源限制。

二、IO差別

1、select的實現

這段可以結合linux核心程式碼描述了，我使用的是2.6.28，其他2.6的程式碼應該差不多吧。
先看看select:
select系統呼叫的程式碼在fs/Select.c下，
asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
fd_set __user *exp, struct timeval __user *tvp)
{
struct timespec end_time, *to = NULL;
struct timeval tv;
int ret;

if (tvp) {
if (copy_from_user(&tv, tvp, sizeof(tv)))
return -EFAULT;

to = &end_time;
if (poll_select_set_timeout(to,
tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
(tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
return -EINVAL;
}

ret = core_sys_select(n, inp, outp, exp, to);
ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);

return ret;
}
前面是從使用者控制元件拷貝各個fd_set到核心空間，接下來的具體工作在core_sys_select中，
core_sys_select->do_select,真正的核心內容在do_select裡：
int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
{
ktime_t expire, *to = NULL;
struct poll_wqueues table;
poll_table *wait;
int retval, i, timed_out = 0;
unsigned long slack = 0;

rcu_read_lock();
retval = max_select_fd(n, fds);
rcu_read_unlock();

if (retval < 0)
return retval;
n = retval;

poll_initwait(&table);
wait = &table.pt;
if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
wait = NULL;
timed_out = 1;
}

if (end_time && !timed_out)
slack = estimate_accuracy(end_time);

retval = 0;
for (;;) {
unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;

set_current_state(TASK_INTERRUPTIBLE);

inp = fds->in; outp = fds->out; exp = fds->ex;
rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
unsigned long in, out, ex, all_bits, bit = 1, mask, j;
unsigned long res_in = 0, res_out = 0, res_ex = 0;
const struct file_operations *f_op = NULL;
struct file *file = NULL;

in = *inp++; out = *outp++; ex = *exp++;
all_bits = in | out | ex;
if (all_bits == 0) {
i += __NFDBITS;
continue;
}

for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
int fput_needed;
if (i >= n)
break;
if (!(bit & all_bits))
continue;
file = fget_light(i, &fput_needed);
if (file) {
f_op = file->f_op;
mask = DEFAULT_POLLMASK;
if (f_op && f_op->poll)
mask = (*f_op->poll)(file, retval ? NULL : wait);
fput_light(file, fput_needed);
if ((mask & POLLIN_SET) && (in & bit)) {
res_in |= bit;
retval++;
}
if ((mask & POLLOUT_SET) && (out & bit)) {
res_out |= bit;
retval++;
}
if ((mask & POLLEX_SET) && (ex & bit)) {
res_ex |= bit;
retval++;
}
}
}
if (res_in)
*rinp = res_in;
if (res_out)
*routp = res_out;
if (res_ex)
*rexp = res_ex;
cond_resched();
}
wait = NULL;
if (retval || timed_out || signal_pending(current))
break;
if (table.error) {
retval = table.error;
break;
}

/*
* If this is the first loop and we have a timeout
* given, then we convert to ktime_t and set the to
* pointer to the expiry value.
*/
if (end_time && !to) {
expire = timespec_to_ktime(*end_time);
to = &expire;
}

if (!schedule_hrtimeout_range(to, slack, HRTIMER_MODE_ABS))
timed_out = 1;
}
__set_current_state(TASK_RUNNING);

poll_freewait(&table);

return retval;
}
上面的程式碼很多，其實真正關鍵的程式碼是這一句:
mask = (*f_op->poll)(file, retval ? NULL : wait);
這個是呼叫檔案系統的 poll函式，不同的檔案系統poll函式自然不同，由於我們這裡關注的是tcp連線，而socketfs的註冊在 net/Socket.c裡。
register_filesystem(&sock_fs_type);
socket檔案系統的函式也是在net/Socket.c裡：
static const struct file_operations socket_file_ops = {
.owner =    THIS_MODULE,
.llseek =    no_llseek,
.aio_read =    sock_aio_read,
.aio_write =    sock_aio_write,
.poll =        sock_poll,
.unlocked_ioctl = sock_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = compat_sock_ioctl,
#endif
.mmap =        sock_mmap,
.open =        sock_no_open,    /* special open code to disallow open via /proc */
.release =    sock_close,
.fasync =    sock_fasync,
.sendpage =    sock_sendpage,
.splice_write = generic_splice_sendpage,
.splice_read =    sock_splice_read,
};
從sock_poll跟隨下去，
最後可以到 net/ipv4/tcp.c的
unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
這個是最終的查詢函式，
也就是說select 的核心功能是呼叫tcp檔案系統的poll函式，不停的查詢，如果沒有想要的資料，主動執行一次排程（防止一直佔用cpu），直到有一個連線有想要的訊息為止。
從這裡可以看出select的執行方式基本就是不同的呼叫poll,直到有需要的訊息為止，如果select 處理的socket很多，這其實對整個機器的效能也是一個消耗。

2、epoll的實現

epoll的實現程式碼在 fs/EventPoll.c下，
由於epoll涉及到幾個系統呼叫，這裡不逐個分析了，僅僅分析幾個關鍵點，
第一個關鍵點在
static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
struct file *tfile, int fd)
這是在我們呼叫sys_epoll_ctl 新增一個被管理socket的時候呼叫的函式，關鍵的幾行如下：
epq.epi = epi;
init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);

/*
* Attach the item to the poll hooks and get current event bits.
* We can safely use the file* here because its usage count has
* been increased by the caller of this function. Note that after
* this operation completes, the poll callback can start hitting
* the new item.
*/
revents = tfile->f_op->poll(tfile, &epq.pt);
這裡也是呼叫檔案系統的poll函式，不過這次初始化了一個結構，這個結構會帶有一個poll函式的callback函式：ep_ptable_queue_proc，
在呼叫poll函式的時候，會執行這個callback，這個callback的功能就是將當前程序新增到 socket的等待程序上。
static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
poll_table *pt)
{
struct epitem *epi = ep_item_from_epqueue(pt);
struct eppoll_entry *pwq;

if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
pwq->whead = whead;
pwq->base = epi;
add_wait_queue(whead, &pwq->wait);
list_add_tail(&pwq->llink, &epi->pwqlist);
epi->nwait++;
} else {
/* We have to signal that an error occurred */
epi->nwait = -1;
}
}
注意到引數 whead 實際上是 sk->sleep，其實就是將當前程序新增到sk的等待佇列裡，當該socket收到資料或者其他事件觸發時，會呼叫
sock_def_readable 或者sock_def_write_space 通知函式來喚醒等待程序，這2個函式都是在socket建立的時候填充在sk結構裡的。
從前面的分析來看，epoll確實是比select聰明的多、輕鬆的多，不用再苦哈哈的去輪詢了。