Every time you call select() or poll(), three expensive things happen:

The combined result: the CPU time consumed grows linearly with the number of file descriptors being monitored, not with the number of active (ready) fds. This is called O(n) scaling — very bad for high-connection servers.

Let’s look at the data structures involved and understand why copying them is expensive.

/*
 * Rough illustration of copy cost with poll() at scale
 *
 * Each struct pollfd = 8 bytes
 * 10,000 connections = 10,000 * 8 = 80,000 bytes per call
 * If poll() is called 1000 times/second:
 *   = 80,000 * 1000 = 80 MB/sec just for copies between user and kernel
 *
 * This is pure overhead unrelated to actual I/O work.
 */

#include <poll.h>
#include <stdlib.h>
#include <stdio.h>

#define MAX_CLIENTS 10000

int main(void)
{
    struct pollfd *fds = malloc(MAX_CLIENTS * sizeof(struct pollfd));
    if (!fds) {
        perror("malloc");
        return 1;
    }

    /* Initialize all entries */
    for (int i = 0; i < MAX_CLIENTS; i++) {
        fds[i].fd     = i + 3;    /* pretend fds start at 3 */
        fds[i].events = POLLIN;
        fds[i].revents = 0;
    }

    /* Every call to poll() copies 80,000 bytes to kernel and back */
    while (1) {
        int ret = poll(fds, MAX_CLIENTS, -1);

        /* After returning, must loop through ALL 10,000 entries */
        for (int i = 0; i < MAX_CLIENTS; i++) {
            if (fds[i].revents & POLLIN) {
                /* handle fd fds[i].fd */
                printf("fd %d is ready\n", fds[i].fd);
                fds[i].revents = 0;
            }
        }
    }

    free(fds);
    return 0;
}

The deepest reason select() and poll() scale poorly is fundamental to their design:

Both signal-driven I/O and epoll solve the root cause problem by letting the kernel maintain a persistent interest list. You register your interest once, and the kernel remembers it across multiple wait operations.

The key insight: select() and poll() performance degrades even when no I/O is happening and the fd set is unchanged. epoll and signal-driven I/O only do work proportional to how much actual I/O activity is occurring.

/*
 * demo_poll_scale.c
 *
 * This shows the O(n) nature of poll():
 * - Create N pipe pairs
 * - Monitor read ends with poll()
 * - Only write to the last one
 * - Notice poll() still scans ALL N entries
 */

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

#define N_PIPES 1000   /* try 10, 100, 1000, 10000 */

int main(void)
{
    int pipes[N_PIPES][2];
    struct pollfd fds[N_PIPES];

    /* Create N pipes */
    for (int i = 0; i < N_PIPES; i++) {
        if (pipe(pipes[i]) == -1) {
            perror("pipe");
            exit(1);
        }
        fds[i].fd     = pipes[i][0];  /* read end */
        fds[i].events = POLLIN;
        fds[i].revents = 0;
    }

    /* Write one byte to the LAST pipe only */
    write(pipes[N_PIPES - 1][1], "x", 1);

    /* Time the poll() call */
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);

    /* poll() must scan ALL N_PIPES entries, even though
     * only the last one is ready */
    int ret = poll(fds, N_PIPES, 0);

    clock_gettime(CLOCK_MONOTONIC, &end);

    long ns = (end.tv_sec - start.tv_sec) * 1000000000L
              + (end.tv_nsec - start.tv_nsec);

    printf("N_PIPES=%d, ret=%d, time=%ld ns\n", N_PIPES, ret, ns);

    /* Check which fd is ready */
    for (int i = 0; i < N_PIPES; i++) {
        if (fds[i].revents & POLLIN)
            printf("Ready: index %d, fd %d\n", i, fds[i].fd);
    }

    /* Cleanup */
    for (int i = 0; i < N_PIPES; i++) {
        close(pipes[i][0]);
        close(pipes[i][1]);
    }
    return 0;
}

/*
 * Compile: gcc -o demo_poll_scale demo_poll_scale.c
 * Run with different N_PIPES values and compare the time output.
 * You will see time grows linearly with N_PIPES.
 * With epoll, time would remain near-constant regardless of N_PIPES.
 */