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

src: use 'queue_node' and 'tree_node' only

Browse Source
This commit is contained in:
Bert Belder 2017-09-11 01:44:25 +02:00
parent 1f795ae60f
commit 854f8a552c
8 changed files with 101 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/epoll-socket.c
View File

@ -57,8 +57,8 @@ ep_sock_t* ep_sock_new(ep_port_t* port_info) {
unused(port_info);
memset(sock_private, 0, sizeof *sock_private);
handle_tree_entry_init(&sock_private->pub.tree_entry);
queue_elem_init(&sock_private->pub.queue_entry);
handle_tree_node_init(&sock_private->pub.tree_node);
queue_node_init(&sock_private->pub.queue_node);
return &sock_private->pub;
}
@ -78,7 +78,7 @@ int ep_sock_delete(ep_port_t* port_info, ep_sock_t* sock_info) {
assert(!_ep_sock_is_deleted(sock_private));
ep_port_del_socket(port_info, &sock_info->tree_entry);
ep_port_del_socket(port_info, &sock_info->tree_node);
ep_port_clear_socket_update(port_info, sock_info);
sock_private->flags |= _EP_SOCK_DELETED;
@ -156,7 +156,7 @@ int ep_sock_set_socket(ep_port_t* port_info,
&sock_private->driver_socket) < 0)
return -1;
if (ep_port_add_socket(port_info, &sock_info->tree_entry, socket) < 0)
if (ep_port_add_socket(port_info, &sock_info->tree_node, socket) < 0)
return -1;
return 0;
@ -303,7 +303,7 @@ int ep_sock_feed_event(ep_port_t* port_info,
return ev_count;
}
ep_sock_t* ep_sock_from_tree_entry(handle_tree_entry_t* tree_entry) {
assert(tree_entry != NULL);
return container_of(tree_entry, ep_sock_t, tree_entry);
ep_sock_t* ep_sock_from_tree_node(handle_tree_node_t* tree_node) {
assert(tree_node != NULL);
return container_of(tree_node, ep_sock_t, tree_node);
}

8
src/epoll-socket.h
View File

@ -15,8 +15,8 @@ typedef struct ep_port ep_port_t;
typedef struct poll_req poll_req_t;
typedef struct ep_sock {
handle_tree_entry_t tree_entry;
queue_elem_t queue_entry;
handle_tree_node_t tree_node;
queue_node_t queue_node;
} ep_sock_t;
EPOLL_INTERNAL ep_sock_t* ep_sock_new(ep_port_t* port_info);
@ -39,7 +39,7 @@ EPOLL_INTERNAL void ep_sock_register_poll_req(ep_port_t* port_info,
EPOLL_INTERNAL void ep_sock_unregister_poll_req(ep_port_t* port_info,
ep_sock_t* sock_info);
EPOLL_INTERNAL ep_sock_t* ep_sock_from_tree_entry(
handle_tree_entry_t* tree_entry);
EPOLL_INTERNAL ep_sock_t* ep_sock_from_tree_node(
handle_tree_node_t* tree_node);
#endif /* EPOLL_SOCK_DATA_H_ */

40
src/epoll.c
View File

@ -49,14 +49,14 @@ static int _ep_ctl_add(ep_port_t* port_info,
static int _ep_ctl_mod(ep_port_t* port_info,
uintptr_t socket,
struct epoll_event* ev) {
handle_tree_entry_t* tree_entry;
handle_tree_node_t* tree_node;
ep_sock_t* sock_info;
tree_entry = handle_tree_find(&port_info->sock_tree, socket);
if (tree_entry == NULL)
tree_node = handle_tree_find(&port_info->sock_tree, socket);
if (tree_node == NULL)
return -1;
sock_info = ep_sock_from_tree_entry(tree_entry);
sock_info = ep_sock_from_tree_node(tree_node);
if (ep_sock_set_event(port_info, sock_info, ev) < 0)
return -1;
@ -65,14 +65,14 @@ static int _ep_ctl_mod(ep_port_t* port_info,
}
static int _ep_ctl_del(ep_port_t* port_info, uintptr_t socket) {
handle_tree_entry_t* tree_entry;
handle_tree_node_t* tree_node;
ep_sock_t* sock_info;
tree_entry = handle_tree_find(&port_info->sock_tree, socket);
if (tree_entry == NULL)
tree_node = handle_tree_find(&port_info->sock_tree, socket);
if (tree_node == NULL)
return -1;
sock_info = ep_sock_from_tree_entry(tree_entry);
sock_info = ep_sock_from_tree_node(tree_node);
if (ep_sock_delete(port_info, sock_info) < 0)
return -1;
@ -104,8 +104,8 @@ static int _ep_port_update_events(ep_port_t* port_info) {
/* Walk the queue, submitting new poll requests for every socket that needs
* it. */
while (!queue_empty(update_queue)) {
queue_elem_t* queue_entry = queue_first(update_queue);
ep_sock_t* sock_info = container_of(queue_entry, ep_sock_t, queue_entry);
queue_node_t* queue_node = queue_first(update_queue);
ep_sock_t* sock_info = container_of(queue_node, ep_sock_t, queue_node);
if (ep_sock_update(port_info, sock_info) < 0)
return -1;
@ -239,7 +239,7 @@ epoll_t epoll_create(void) {
int epoll_close(epoll_t port_handle) {
ep_port_t* port_info;
handle_tree_entry_t* tree_entry;
handle_tree_node_t* tree_node;
port_info = (ep_port_t*) port_handle;
@ -281,8 +281,8 @@ int epoll_close(epoll_t port_handle) {
}
/* Remove all entries from the socket_state tree. */
while ((tree_entry = handle_tree_root(&port_info->sock_tree)) != NULL) {
ep_sock_t* sock_info = ep_sock_from_tree_entry(tree_entry);
while ((tree_node = handle_tree_root(&port_info->sock_tree)) != NULL) {
ep_sock_t* sock_info = ep_sock_from_tree_node(tree_node);
ep_sock_delete(port_info, sock_info);
}
@ -311,13 +311,13 @@ static int _ep_initialize(void) {
}
int ep_port_add_socket(ep_port_t* port_info,
handle_tree_entry_t* tree_entry,
handle_tree_node_t* tree_node,
SOCKET socket) {
return handle_tree_add(&port_info->sock_tree, tree_entry, socket);
return handle_tree_add(&port_info->sock_tree, tree_node, socket);
}
int ep_port_del_socket(ep_port_t* port_info, handle_tree_entry_t* tree_entry) {
return handle_tree_del(&port_info->sock_tree, tree_entry);
int ep_port_del_socket(ep_port_t* port_info, handle_tree_node_t* tree_node) {
return handle_tree_del(&port_info->sock_tree, tree_node);
}
void ep_port_add_req(ep_port_t* port_info) {
@ -401,19 +401,19 @@ error:;
bool ep_port_is_socket_update_pending(ep_port_t* port_info,
ep_sock_t* sock_info) {
unused(port_info);
return queue_enqueued(&sock_info->queue_entry);
return queue_enqueued(&sock_info->queue_node);
}
void ep_port_request_socket_update(ep_port_t* port_info,
ep_sock_t* sock_info) {
if (ep_port_is_socket_update_pending(port_info, sock_info))
return;
queue_append(&port_info->update_queue, &sock_info->queue_entry);
queue_append(&port_info->update_queue, &sock_info->queue_node);
assert(ep_port_is_socket_update_pending(port_info, sock_info));
}
void ep_port_clear_socket_update(ep_port_t* port_info, ep_sock_t* sock_info) {
if (!ep_port_is_socket_update_pending(port_info, sock_info))
return;
queue_remove(&sock_info->queue_entry);
queue_remove(&sock_info->queue_node);
}

55
src/handle-tree.c
View File

@ -4,8 +4,8 @@
#include "handle-tree.h"
#include "tree.h"
static inline int _handle_tree_compare(handle_tree_entry_t* a,
handle_tree_entry_t* b) {
static inline int _handle_tree_compare(handle_tree_node_t* a,
handle_tree_node_t* b) {
if (a->key < b->key)
return -1;
else if (a->key > b->key)
@ -14,61 +14,58 @@ static inline int _handle_tree_compare(handle_tree_entry_t* a,
return 0;
}
RB_GENERATE_STATIC(handle_tree,
handle_tree_entry,
entry,
_handle_tree_compare);
RB_GENERATE_STATIC(handle_tree, handle_tree_node, node, _handle_tree_compare);
void handle_tree_init(handle_tree_t* tree) {
RB_INIT(tree);
}
void handle_tree_entry_init(handle_tree_entry_t* entry) {
memset(entry, 0, sizeof *entry);
void handle_tree_node_init(handle_tree_node_t* node) {
memset(node, 0, sizeof *node);
}
int handle_tree_add(handle_tree_t* tree,
handle_tree_entry_t* entry,
handle_tree_node_t* node,
uintptr_t key) {
handle_tree_entry_t* existing_entry;
handle_tree_node_t* existing_node;
if (key == 0)
return_error(-1, ERROR_INVALID_PARAMETER);
if (entry->key != 0)
if (node->key != 0)
return_error(-1, ERROR_ALREADY_EXISTS);
entry->key = key;
existing_entry = RB_INSERT(handle_tree, tree, entry);
node->key = key;
existing_node = RB_INSERT(handle_tree, tree, node);
if (existing_entry != NULL) {
entry->key = 0;
if (existing_node != NULL) {
node->key = 0;
return_error(-1, ERROR_ALREADY_EXISTS);
}
return 0;
}
int handle_tree_del(handle_tree_t* tree, handle_tree_entry_t* entry) {
handle_tree_entry_t* removed_entry;
int handle_tree_del(handle_tree_t* tree, handle_tree_node_t* node) {
handle_tree_node_t* removed_node;
if (entry->key == 0)
if (node->key == 0)
return_error(-1, ERROR_NOT_FOUND);
removed_entry = RB_REMOVE(handle_tree, tree, entry);
removed_node = RB_REMOVE(handle_tree, tree, node);
if (removed_entry == NULL)
if (removed_node == NULL)
return_error(-1, ERROR_NOT_FOUND);
else
assert(removed_entry == entry);
assert(removed_node == node);
entry->key = 0;
node->key = 0;
return 0;
}
handle_tree_entry_t* handle_tree_find(handle_tree_t* tree, uintptr_t key) {
handle_tree_entry_t* entry;
handle_tree_entry_t lookup;
handle_tree_node_t* handle_tree_find(handle_tree_t* tree, uintptr_t key) {
handle_tree_node_t* node;
handle_tree_node_t lookup;
if (key == 0)
return_error(NULL, ERROR_INVALID_PARAMETER);
@ -76,13 +73,13 @@ handle_tree_entry_t* handle_tree_find(handle_tree_t* tree, uintptr_t key) {
memset(&lookup, 0, sizeof lookup);
lookup.key = key;
entry = RB_FIND(handle_tree, tree, &lookup);
if (entry == NULL)
node = RB_FIND(handle_tree, tree, &lookup);
if (node == NULL)
return_error(NULL, ERROR_NOT_FOUND);
return entry;
return node;
}
handle_tree_entry_t* handle_tree_root(handle_tree_t* tree) {
handle_tree_node_t* handle_tree_root(handle_tree_t* tree) {
return RB_ROOT(tree);
}

20
src/handle-tree.h
View File

@ -4,24 +4,24 @@
#include "internal.h"
#include "tree.h"
typedef RB_HEAD(handle_tree, handle_tree_entry) handle_tree_t;
typedef RB_HEAD(handle_tree, handle_tree_node) handle_tree_t;
typedef struct handle_tree_entry {
RB_ENTRY(handle_tree_entry) entry;
typedef struct handle_tree_node {
RB_ENTRY(handle_tree_node) node;
uintptr_t key;
} handle_tree_entry_t;
} handle_tree_node_t;
EPOLL_INTERNAL void handle_tree_init(handle_tree_t* tree);
EPOLL_INTERNAL void handle_tree_entry_init(handle_tree_entry_t* entry);
EPOLL_INTERNAL void handle_tree_node_init(handle_tree_node_t* node);
EPOLL_INTERNAL int handle_tree_add(handle_tree_t* tree,
handle_tree_entry_t* entry,
handle_tree_node_t* node,
uintptr_t key);
EPOLL_INTERNAL int handle_tree_del(handle_tree_t* tree,
handle_tree_entry_t* entry);
handle_tree_node_t* node);
EPOLL_INTERNAL handle_tree_entry_t* handle_tree_find(handle_tree_t* tree,
uintptr_t key);
EPOLL_INTERNAL handle_tree_entry_t* handle_tree_root(handle_tree_t* tree);
EPOLL_INTERNAL handle_tree_node_t* handle_tree_find(handle_tree_t* tree,
uintptr_t key);
EPOLL_INTERNAL handle_tree_node_t* handle_tree_root(handle_tree_t* tree);
#endif /* EPOLL_HANDLE_TREE_H_ */

4
src/port.h
View File

@ -25,10 +25,10 @@ EPOLL_INTERNAL SOCKET ep_port_get_driver_socket(ep_port_t* port_info,
SOCKET socket);
EPOLL_INTERNAL int ep_port_add_socket(ep_port_t* port_info,
handle_tree_entry_t* tree_entry,
handle_tree_node_t* tree_node,
SOCKET socket);
EPOLL_INTERNAL int ep_port_del_socket(ep_port_t* port_info,
handle_tree_entry_t* tree_entry);
handle_tree_node_t* tree_node);
EPOLL_INTERNAL void ep_port_add_req(ep_port_t* port_info);
EPOLL_INTERNAL void ep_port_del_req(ep_port_t* port_info);

58
src/queue.h
View File

@ -6,59 +6,59 @@
#include "internal.h"
typedef struct queue_elem queue_elem_t;
typedef struct queue_elem {
queue_elem_t* prev;
queue_elem_t* next;
} queue_elem_t;
typedef struct queue_node queue_node_t;
typedef struct queue_node {
queue_node_t* prev;
queue_node_t* next;
} queue_node_t;
typedef struct queue {
queue_elem_t head;
queue_node_t head;
} queue_t;
EPOLL_INTERNAL inline void queue_elem_init(queue_elem_t* elem) {
elem->prev = elem;
elem->next = elem;
EPOLL_INTERNAL inline void queue_node_init(queue_node_t* node) {
node->prev = node;
node->next = node;
}
EPOLL_INTERNAL inline void queue_init(queue_t* queue) {
queue_elem_init(&queue->head);
queue_node_init(&queue->head);
}
EPOLL_INTERNAL inline bool queue_enqueued(const queue_elem_t* elem) {
return elem->prev != elem;
EPOLL_INTERNAL inline bool queue_enqueued(const queue_node_t* node) {
return node->prev != node;
}
EPOLL_INTERNAL inline bool queue_empty(const queue_t* queue) {
return !queue_enqueued(&queue->head);
}
EPOLL_INTERNAL inline queue_elem_t* queue_first(const queue_t* queue) {
EPOLL_INTERNAL inline queue_node_t* queue_first(const queue_t* queue) {
return !queue_empty(queue) ? queue->head.next : NULL;
}
EPOLL_INTERNAL inline queue_elem_t* queue_last(const queue_t* queue) {
EPOLL_INTERNAL inline queue_node_t* queue_last(const queue_t* queue) {
return !queue_empty(queue) ? queue->head.prev : NULL;
}
EPOLL_INTERNAL inline void queue_prepend(queue_t* queue, queue_elem_t* elem) {
elem->next = queue->head.next;
elem->prev = &queue->head;
elem->next->prev = elem;
queue->head.next = elem;
EPOLL_INTERNAL inline void queue_prepend(queue_t* queue, queue_node_t* node) {
node->next = queue->head.next;
node->prev = &queue->head;
node->next->prev = node;
queue->head.next = node;
}
EPOLL_INTERNAL inline void queue_append(queue_t* queue, queue_elem_t* elem) {
elem->next = &queue->head;
elem->prev = queue->head.prev;
elem->prev->next = elem;
queue->head.prev = elem;
EPOLL_INTERNAL inline void queue_append(queue_t* queue, queue_node_t* node) {
node->next = &queue->head;
node->prev = queue->head.prev;
node->prev->next = node;
queue->head.prev = node;
}
EPOLL_INTERNAL inline void queue_remove(queue_elem_t* elem) {
elem->prev->next = elem->next;
elem->next->prev = elem->prev;
elem->prev = elem;
elem->next = elem;
EPOLL_INTERNAL inline void queue_remove(queue_node_t* node) {
node->prev->next = node->next;
node->next->prev = node->prev;
node->prev = node;
node->next = node;
}
#endif /* QUEUE_H_ */

6
src/tree.h
View File

@ -63,9 +63,9 @@ struct name { \
#define RB_RED 1
#define RB_ENTRY(type) \
struct { \
struct type *rbe_left; /* left element */ \
struct type *rbe_right; /* right element */ \
struct type *rbe_parent; /* parent element */ \
struct type *rbe_left; /* left nodeent */ \
struct type *rbe_right; /* right nodeent */ \
struct type *rbe_parent; /* parent nodeent */ \
int rbe_color; /* node color */ \
}