c - 处理/定义 poll 系统调用的 struct pollfd 数组的有效方法

Question

我正在使用 poll 来实现具有多路复用的客户端-服务器模型的服务器端。

服务器正在运行一个主循环。
在每个循环中，我都会检查 struct pollfd 数组中的所有 fd，直到找到包含我内容的 n 个套接字(其中 n 是 poll 返回的数字)。
此外，使用 poll 时不会超时(-1 作为参数)。

因此，如果在监听套接字上请求新连接，我会将套接字和一些客户端信息插入到我保留的事件连接列表中。

处理 poll 数组最有效的方法是什么？

我是否应该定义一个大小为 10 的小数组，并且如果有更多客户端为大小为 20 或 50 的数组重新分配内存？

或者我应该:(a)释放struct pollfd类型的数组，并且(b)重新分配它，其大小等于列表的大小(监听套接字+1)=>每次客户端关闭时一个连接(因此我必须从数组中删除一个元素(可能将套接字设置为-1，以便 poll 忽略它)导致数组中出现未使用的空间)

你有什么推荐？

感谢您的宝贵时间

---

编辑:我想我已经找到了一个解决方案，每次客户端断开连接时都使用 realloc 和 memmove 进行移位，以覆盖 fds 数组中的套接字。

Answer 1

What is the most efficient way to handle the array of poll?

实现定义的。在您知道必须进行优化之前不要进行优化；这就是所谓的过早优化，而且是浪费时间。

Should I define a small array of size 10 and if there are more clients re allocate memory for an array of size 20 or 50?

如果您的分析器确定您的 pollfd 是程序中的一个重要瓶颈，并且您的老板(或教授)说您的程序“不够快” ， 大胆试试吧。如果您的列表将获得的最大数量是 50，那么只需使用静态数组，将 fd 成员设置为 -1，当您从数组...您所指的瓶颈对于这么小的数字来说是微不足道的。

如果您在最坏的情况下尝试处理大量的客户端，您可能会担心在处理较小的数字时尾随数组的未使用空间......因此会选择可调整大小的 pollfd 数组。

Or should I: (a) free the array of struct pollfd type, and (b) reallocate it with size that is equal to the size of the list(+1 for the listening socket) => every time a client closes a connection (and thus I have to remove an element from the array (probably setting the socket to -1, so that poll ignores it) resulting in unused space in array)

我能想到的最简单的算法是在调整大小时将空间加倍。与线性调整大小相比，加倍调整大小最显着的好处可能是减少了对 realloc 的调用；我宁愿接受 1024 个连接并调用 realloc 10 或 11 次，而不是接受 1024 个连接并调用 realloc 1024 次。对我来说这也似乎更简单，因为不需要将数组容量与已使用的计数分开存储；您可以利用二进制数的属性来发挥自己的优势:当 n 是 2 的幂时，(n - 1) & n == 0。

#define is_power_of_two(n) !(((n) - 1) & (n))

struct pollfd *pollfd_array_resize(struct pollfd *array, size_t size) {
    const size_t max_size = SIZE_MAX / sizeof *array;
    if (size == max_size) { return NULL; }
    if (is_power_of_two(size)) {
        array = realloc(array, (size > 0 ? size * 2 : 1) * sizeof *array);
    }
    return array;
}

Edit: I think I've found a solution with realloc and shifting with memmove each time a client disconnects to cover his socket at the fds array.

这似乎是一个相当好的解决方案。它增加了缓存局部性，但代价是每次客户端断开连接时都必须调用 memmove 和 realloc。

我什至不会考虑对数组进行“碎片整理”，直到我的探查器表明 poll 占用了太多处理器时间。发生这种情况时，我会考虑将 fd 成员设置为负值(正如您在编辑之前所做的那样)并将要删除的项目的索引放入recently_freed 堆栈。插入时，如果可能的话，我会从该堆栈中选择项目。如果您必须进行碎片整理，我建议根据该堆栈的大小进行碎片整理。

size_t pollfd_array_defrag(struct pollfd *array, size_t size) {
    size_t new_size = 0;
    for (size_t x = 0; x + 1 < size; x++) {
        if (array[x].fd < 0) {
            continue;
        }

        array[new_size++] = array[x];
    }
    return new_size;
}

int main(void) {
    size_t size = 0, index;
    struct pollfd *array = NULL;
    struct index_stack *recently_freed = NULL;

    /*----------------------------*
     * ... snip for insertion ... */
    if (recently_freed && recently_freed->size > 0) {
        index = index_stack_pop(&recently_freed);
    }
    else {
        struct pollfd *temp = pollfd_array_resize(array, size);

        if (temp == NULL) {
            /* TODO: Handle memory allocation errors */
        }

        array = temp;
        index = size++;
    }

    array[index] = (struct pollfd) { .fd = your_fd,
                                     .events = your_events,
                                     .revents = your_revents };

    /*--------------------------*
     * ... snip for removal ... */
    index_stack_push(&recently_freed, index);
    array[index] = -1;

    /*----------------------------------*
     * ... snip for defragmentation ... */
    if (is_power_of_two(recently_freed->size) && recently_freed->size * 2 + 1 > size) {
        size = pollfd_array_defrag(array);
        /* array will shrink in future insertions */
        index_stack_destroy(&recently_freed);
        recently_freed = NULL;
    }
}