处理/定义 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

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

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

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

如果你的分析器确定你pollfd的程序是程序中的一个重要瓶颈，并且你的老板（或教授）说你的程序“不够快”，那就继续吧。如果您的列表将获得的最大数量是 50，那么只需使用静态数组，将fd成员设置为-1，当您从数组中删除时不必费心移动事物...您所指的瓶颈对于此类来说是微不足道的一小部分。

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

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

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

#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;
}

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

这似乎是一个相当好的解决方案。它增加了缓存局部性，但代价是每次客户端断开连接时都必须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;
    }
}