packet_queue.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
// C11 stdatomic.h conflicts with MSVC's C++ <atomic> header on Windows.
#if defined(__cplusplus) && defined(_WIN32)
#include <atomic>
using std::atomic_size_t;
#else
#include <stdatomic.h>
#endif
#include "buffer_pool.h"
#include "network/packet.h"
 
typedef struct {
  packet_header_t header;
  void *data;
  size_t data_len;
  bool owns_data;
  buffer_pool_t *buffer_pool;
} queued_packet_t;
 
typedef struct packet_node packet_node_t;
 
struct packet_node {
  queued_packet_t packet;
  _Atomic(packet_node_t *) next;
};
 
typedef struct node_pool {
  packet_node_t *free_list;
  packet_node_t *nodes;
  size_t pool_size;
  size_t used_count;
  mutex_t pool_mutex;
} node_pool_t;
 
typedef struct {
  _Atomic(packet_node_t *) head;
  _Atomic(packet_node_t *) tail;
  _Atomic size_t count;
  size_t max_size;
  _Atomic size_t bytes_queued;
 
  node_pool_t *node_pool;
  buffer_pool_t *buffer_pool;
 
  _Atomic uint64_t packets_enqueued;
  _Atomic uint64_t packets_dequeued;
  _Atomic uint64_t packets_dropped;
 
  _Atomic bool shutdown;
} packet_queue_t;
 
node_pool_t *node_pool_create(size_t pool_size);
 
void node_pool_destroy(node_pool_t *pool);
 
packet_node_t *node_pool_get(node_pool_t *pool);
 
void node_pool_put(node_pool_t *pool, packet_node_t *node);
 
packet_queue_t *packet_queue_create(size_t max_size);
 
packet_queue_t *packet_queue_create_with_pool(size_t max_size, size_t pool_size);
 
packet_queue_t *packet_queue_create_with_pools(size_t max_size, size_t node_pool_size, bool use_buffer_pool);
 
void packet_queue_destroy(packet_queue_t *queue);
 
int packet_queue_enqueue(packet_queue_t *queue, packet_type_t type, const void *data, size_t data_len,
                         uint32_t client_id, bool copy_data);
 
int packet_queue_enqueue_packet(packet_queue_t *queue, const queued_packet_t *packet);
 
queued_packet_t *packet_queue_dequeue(packet_queue_t *queue);
 
queued_packet_t *packet_queue_try_dequeue(packet_queue_t *queue);
 
void packet_queue_free_packet(queued_packet_t *packet);
 
size_t packet_queue_size(packet_queue_t *queue);
 
bool packet_queue_is_empty(packet_queue_t *queue);
 
bool packet_queue_is_full(packet_queue_t *queue);
 
void packet_queue_shutdown(packet_queue_t *queue);
 
void packet_queue_clear(packet_queue_t *queue);
 
void packet_queue_get_stats(packet_queue_t *queue, uint64_t *enqueued, uint64_t *dequeued, uint64_t *dropped);
 
bool packet_queue_validate_packet(const queued_packet_t *packet);