coffee/wepoll
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

poll-group: do away with the poll_group_allocator class

Browse Source
This commit is contained in:
Bert Belder 2018-05-02 03:00:45 +02:00
parent dfeefa8780
commit c07cc8f7cc
No known key found for this signature in database
GPG Key ID: 7A77887B2E2ED461
4 changed files with 30 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/poll-group.c
View File

@ -9,19 +9,14 @@
static const size_t _POLL_GROUP_MAX_SIZE = 32;
typedef struct poll_group_allocator {
ep_port_t* port_info;
queue_t poll_group_queue;
} poll_group_allocator_t;
typedef struct poll_group {
poll_group_allocator_t* allocator;
ep_port_t* port_info;
queue_node_t queue_node;
SOCKET socket;
size_t group_size;
} poll_group_t;
static poll_group_t* _poll_group_new(poll_group_allocator_t* pga) {
static poll_group_t* _poll_group_new(ep_port_t* port_info) {
poll_group_t* poll_group = malloc(sizeof *poll_group);
if (poll_group == NULL)
return_error(NULL, ERROR_NOT_ENOUGH_MEMORY);
@ -29,79 +24,58 @@ static poll_group_t* _poll_group_new(poll_group_allocator_t* pga) {
memset(poll_group, 0, sizeof *poll_group);
queue_node_init(&poll_group->queue_node);
poll_group->allocator = pga;
poll_group->port_info = port_info;
if (afd_create_driver_socket(pga->port_info->iocp, &poll_group->socket) <
0) {
if (afd_create_driver_socket(port_info->iocp, &poll_group->socket) < 0) {
free(poll_group);
return NULL;
}
queue_append(&pga->poll_group_queue, &poll_group->queue_node);
queue_append(&port_info->poll_group_queue, &poll_group->queue_node);
return poll_group;
}
static void _poll_group_delete(poll_group_t* poll_group) {
void poll_group_delete(poll_group_t* poll_group) {
assert(poll_group->group_size == 0);
closesocket(poll_group->socket);
queue_remove(&poll_group->queue_node);
free(poll_group);
}
poll_group_t* poll_group_from_queue_node(queue_node_t* queue_node) {
return container_of(queue_node, poll_group_t, queue_node);
}
SOCKET poll_group_get_socket(poll_group_t* poll_group) {
return poll_group->socket;
}
poll_group_allocator_t* poll_group_allocator_new(ep_port_t* port_info) {
poll_group_allocator_t* pga = malloc(sizeof *pga);
if (pga == NULL)
return_error(NULL, ERROR_NOT_ENOUGH_MEMORY);
queue_init(&pga->poll_group_queue);
pga->port_info = port_info;
return pga;
}
void poll_group_allocator_delete(poll_group_allocator_t* pga) {
queue_t* poll_group_queue = &pga->poll_group_queue;
while (!queue_empty(poll_group_queue)) {
queue_node_t* queue_node = queue_first(poll_group_queue);
poll_group_t* poll_group =
container_of(queue_node, poll_group_t, queue_node);
_poll_group_delete(poll_group);
}
free(pga);
}
poll_group_t* poll_group_acquire(poll_group_allocator_t* pga) {
queue_t* queue = &pga->poll_group_queue;
poll_group_t* poll_group_acquire(ep_port_t* port_info) {
queue_t* queue = &port_info->poll_group_queue;
poll_group_t* poll_group =
!queue_empty(queue)
? container_of(queue_last(queue), poll_group_t, queue_node)
: NULL;
if (poll_group == NULL || poll_group->group_size >= _POLL_GROUP_MAX_SIZE)
poll_group = _poll_group_new(pga);
poll_group = _poll_group_new(port_info);
if (poll_group == NULL)
return NULL;
if (++poll_group->group_size == _POLL_GROUP_MAX_SIZE)
queue_move_first(&pga->poll_group_queue, &poll_group->queue_node);
queue_move_first(&port_info->poll_group_queue, &poll_group->queue_node);
return poll_group;
}
void poll_group_release(poll_group_t* poll_group) {
poll_group_allocator_t* pga = poll_group->allocator;
ep_port_t* port_info = poll_group->port_info;
poll_group->group_size--;
assert(poll_group->group_size < _POLL_GROUP_MAX_SIZE);
queue_move_last(&pga->poll_group_queue, &poll_group->queue_node);
queue_move_last(&port_info->poll_group_queue, &poll_group->queue_node);
/* TODO: free the poll_group_t* item at some point. */
/* Poll groups are currently only freed when the epoll port is closed. */
}

11
src/poll-group.h
View File

@ -7,16 +7,15 @@
#include "win.h"
typedef struct ep_port ep_port_t;
typedef struct poll_group_allocator poll_group_allocator_t;
typedef struct poll_group poll_group_t;
WEPOLL_INTERNAL poll_group_allocator_t* poll_group_allocator_new(
ep_port_t* port_info);
WEPOLL_INTERNAL void poll_group_allocator_delete(poll_group_allocator_t* pga);
WEPOLL_INTERNAL poll_group_t* poll_group_acquire(ep_port_t* port);
WEPOLL_INTERNAL void poll_group_release(poll_group_t* poll_group);
WEPOLL_INTERNAL poll_group_t* poll_group_acquire(poll_group_allocator_t* pga);
WEPOLL_INTERNAL void poll_group_release(poll_group_t* ds);
WEPOLL_INTERNAL void poll_group_delete(poll_group_t* poll_group);
WEPOLL_INTERNAL poll_group_t* poll_group_from_queue_node(
queue_node_t* queue_node);
WEPOLL_INTERNAL SOCKET poll_group_get_socket(poll_group_t* poll_group);
#endif /* WEPOLL_POLL_GROUP_H_ */

21
src/port.c
View File

@ -50,9 +50,10 @@ ep_port_t* ep_port_new(HANDLE* iocp_out) {
memset(port_info, 0, sizeof *port_info);
port_info->iocp = iocp;
tree_init(&port_info->sock_tree);
queue_init(&port_info->sock_update_queue);
queue_init(&port_info->sock_deleted_queue);
tree_init(&port_info->sock_tree);
queue_init(&port_info->poll_group_queue);
reflock_tree_node_init(&port_info->handle_tree_node);
InitializeCriticalSection(&port_info->lock);
@ -102,8 +103,10 @@ int ep_port_delete(ep_port_t* port_info) {
ep_sock_force_delete(port_info, sock_info);
}
if (port_info->poll_group_allocator != NULL)
poll_group_allocator_delete(port_info->poll_group_allocator);
while ((queue_node = queue_first(&port_info->poll_group_queue)) != NULL) {
poll_group_t* poll_group = poll_group_from_queue_node(queue_node);
poll_group_delete(poll_group);
}
DeleteCriticalSection(&port_info->lock);
@ -356,18 +359,8 @@ ep_sock_t* ep_port_find_socket(ep_port_t* port_info, SOCKET socket) {
return sock_info;
}
static poll_group_allocator_t* _ep_port_get_poll_group_allocator(
ep_port_t* port_info) {
if (port_info->poll_group_allocator == NULL) {
port_info->poll_group_allocator = poll_group_allocator_new(port_info);
}
return port_info->poll_group_allocator;
}
poll_group_t* ep_port_acquire_poll_group(ep_port_t* port_info) {
poll_group_allocator_t* pga = _ep_port_get_poll_group_allocator(port_info);
return poll_group_acquire(pga);
return poll_group_acquire(port_info);
}
void ep_port_release_poll_group(ep_port_t* port_info,

2
src/port.h
View File

@ -16,10 +16,10 @@ typedef struct ep_sock ep_sock_t;
typedef struct ep_port {
HANDLE iocp;
poll_group_allocator_t* poll_group_allocator;
tree_t sock_tree;
queue_t sock_update_queue;
queue_t sock_deleted_queue;
queue_t poll_group_queue;
reflock_tree_node_t handle_tree_node;
CRITICAL_SECTION lock;
size_t active_poll_count;