buffer.h File Reference

Go to the source code of this file.

Data Structures
struct	buffer_domain_config_t
struct	buffer_stats_t
struct	buffer_workspace_t
	Owns the temporary storage used by buffer workspace. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed. More...

Macros
#define	BUFFER_DEFAULT_ALIGNMENT   64u
#define	BUFFER_PROCESS_LIMIT   ((size_t)512 * 1024 * 1024)
#define	BUFFER_CONTROL_RESERVE   ((size_t)8 * 1024 * 1024)
#define	BUFFER_DOMAIN_LIMIT   (BUFFER_PROCESS_LIMIT - BUFFER_CONTROL_RESERVE)
#define	buffer_release(data)

Typedefs
typedef struct buffer_domain	buffer_domain_t

Functions
asciichat_error_t	buffer_domain_create (const buffer_domain_config_t *config, buffer_domain_t **out)
void	buffer_domain_close (buffer_domain_t **domain)
void	buffer_domain_trim (buffer_domain_t *domain)
void	buffer_domain_stats (buffer_domain_t *domain, buffer_stats_t *out)
void	buffer_domain_log_stats (buffer_domain_t *domain, const char *name)
size_t	buffer_process_reserved (void)
asciichat_error_t	buffer_budget_reserve (buffer_budget_t *budget, size_t bytes)
void	buffer_budget_release (buffer_budget_t *budget)
asciichat_error_t	buffer_acquire (buffer_domain_t *domain, size_t size, size_t alignment, void **out)
void *	buffer_alloc (buffer_domain_t *domain, size_t size)
size_t	buffer_capacity (const void *data)
size_t	buffer_size (const void *data)
asciichat_error_t	buffer_set_size (void *data, size_t size)
const void *	buffer_share (const void *data)
bool	buffer_is_unique (const void *data)
void	buffer_unref (const void *data)
asciichat_error_t	buffer_workspace_reserve (buffer_workspace_t *workspace, buffer_domain_t *domain, size_t capacity)
void	buffer_workspace_destroy (buffer_workspace_t *workspace)
void	buffer_system_init (void)
void	buffer_system_cleanup (void)
buffer_domain_t *	buffer_default_domain (void)
buffer_domain_t *	buffer_control_domain (void)

Macro Definition Documentation

BUFFER_CONTROL_RESERVE

#define BUFFER_CONTROL_RESERVE   ((size_t)8 * 1024 * 1024)

Definition at line 28 of file buffer.h.

Referenced by buffer_system_init().

BUFFER_DEFAULT_ALIGNMENT

#define BUFFER_DEFAULT_ALIGNMENT   64u

Definition at line 26 of file buffer.h.

Referenced by buffer_acquire(), buffer_alloc(), buffer_workspace_reserve(), and image_new().

BUFFER_DOMAIN_LIMIT

#define BUFFER_DOMAIN_LIMIT   (BUFFER_PROCESS_LIMIT - BUFFER_CONTROL_RESERVE)

Definition at line 29 of file buffer.h.

Referenced by buffer_domain_create().

BUFFER_PROCESS_LIMIT

#define BUFFER_PROCESS_LIMIT   ((size_t)512 * 1024 * 1024)

Definition at line 27 of file buffer.h.

buffer_release

#define buffer_release

(

data

)

Value:

  do {                                                                                                                 \
    __typeof__(&(data)) buffer_slot__ = &(data);                                                                       \
    buffer_unref(*buffer_slot__);                                                                                      \
    *buffer_slot__ = NULL;                                                                                             \
  } while (0)

Release and clear a typed pointer lvalue; evaluates the lvalue once.

Definition at line 91 of file buffer.h.

#define buffer_release(data)                                                                                           \
  do {                                                                                                                 \
    __typeof__(&(data)) buffer_slot__ = &(data);                                                                       \
    buffer_unref(*buffer_slot__);                                                                                      \
    *buffer_slot__ = NULL;                                                                                             \
  } while (0)

Referenced by acip_async_tcp_client_create(), acip_client_receive_and_dispatch(), acip_packet_encrypt(), acip_packet_seal(), acip_security_decrypt(), acip_security_flush(), acip_send_audio_batch(), acip_send_audio_opus_batch(), acip_send_error(), acip_send_image_frame_h265(), acip_send_remote_log(), acip_server_receive_and_dispatch(), audio_ring_buffer_destroy(), av_send_audio_opus_batch(), browser_security_output(), browser_security_packet(), buffer_workspace_destroy(), buffer_workspace_reserve(), client_decrypt_packet(), client_encrypt_packet(), client_handle_crypto_parameters(), compress_data(), crypto_record_open_sequence(), crypto_record_seal_into_domain(), framebuffer_clear(), framebuffer_read_frame(), framebuffer_write_frame(), framebuffer_write_multi_frame(), image_destroy(), mixer_create_channels(), mixer_destroy(), packet_decoder_reset(), packet_decrypt_envelope(), packet_queue_free_packet(), packet_queue_push_copy(), packet_queue_push_shared(), packet_receive(), packet_receive_via_transport(), peer_crypto_destroy(), peer_crypto_output_pop(), peer_crypto_receive(), quic_connection_destroy(), quic_connection_enable_security(), quic_connection_submit(), quic_connection_submit_datagram(), quic_datagram_read(), receive_packet_secure_with_timeout(), send_image_frame_packet(), send_packet_secure(), video_frame_buffer_create(), video_frame_buffer_destroy(), websocket_transport_send(), and websocket_transport_write_pending().

Typedef Documentation

buffer_domain_t

typedef struct buffer_domain buffer_domain_t

Owned, aligned payloads for synchronous and asynchronous media pipelines.

A returned payload pointer is an ownership token. Only pointers returned by this API may be released or queried; interior pointers are borrowed views. Capacity, allocation origin and domain lifetime are private implementation details. Ordinary objects continue to use SAFE_MALLOC/SAFE_FREE.

Buffers are exclusive until buffer_share() is called. Shared buffers must be treated as immutable. Each owner releases exactly once. Transfer a pointer by clearing the source after a successful handoff; failure preserves it.

Domains serialize allocation, return and trim. No allocator operation is suitable for a real-time audio callback: reserve and touch storage first.

Definition at line 24 of file buffer.h.

Function Documentation

buffer_acquire()

asciichat_error_t buffer_acquire	(	buffer_domain_t *	domain,
		size_t	size,
		size_t	alignment,
		void **	out )

NULL domain selects the default process domain. Failure leaves *out NULL.

Definition at line 178 of file buffer.c.

                                                                                                     {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Buffer output is NULL");
  *out = NULL;
  if (!alignment)
    alignment = BUFFER_DEFAULT_ALIGNMENT;
  if (alignment < sizeof(void *) || (alignment & (alignment - 1)) || alignment > 4096)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Buffer alignment must be a power of two between pointer size and 4096");
  if (!domain)
    domain = buffer_default_domain();
  if (!domain)
    return SET_ERRNO(ERROR_INVALID_STATE, "Buffer system is unavailable");
 
  size_t capacity = BUFFER_MIN_CAPACITY;
  unsigned bin = 0;
  while (capacity < size && bin + 1 < BUFFER_BINS) {
    capacity *= 2;
    bin++;
  }
  if (capacity < size)
    capacity = size;
  size_t overhead = sizeof(buffer_header_t) + sizeof(buffer_header_t *) + alignment - 1;
  if (capacity > SIZE_MAX - overhead)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Buffer capacity overflow");
  size_t charge = capacity + overhead;
 
  mutex_lock(&domain->mutex);
  if (domain->closing) {
    mutex_unlock(&domain->mutex);
    return SET_ERRNO(ERROR_INVALID_STATE, "Buffer domain is closing");
  }
  buffer_header_t **link = &domain->bins[bin];
  buffer_header_t *node = NULL;
  if (capacity <= BUFFER_MAX_CACHED) {
    while (*link) {
      if ((*link)->alignment >= alignment) {
        node = *link;
        *link = node->next;
        domain->stats.cached_bytes -= node->charge;
        domain->stats.hits++;
        break;
      }
      link = &(*link)->next;
    }
  }
  if (!node) {
    if (charge > domain->config.limit_bytes || domain->stats.reserved_bytes > domain->config.limit_bytes - charge) {
      /* A miss may reclaim idle capacity, but a release never scans a pool. */
      trim_locked(domain, true);
    }
    bool fits =
        charge <= domain->config.limit_bytes && domain->stats.reserved_bytes <= domain->config.limit_bytes - charge;
    bool reserved = fits && process_reserve(charge, domain->config.control);
    if (fits && !reserved && domain->stats.cached_bytes) {
      trim_locked(domain, true);
      reserved = process_reserve(charge, domain->config.control);
    }
    if (!reserved) {
      domain->stats.failures++;
      mutex_unlock(&domain->mutex);
      return SET_ERRNO(ERROR_MEMORY, "Buffer budget exhausted requesting %zu bytes", size);
    }
    node = ALLOC_MALLOC(charge);
    if (!node) {
      atomic_fetch_sub_u64(&process_bytes, charge);
      domain->stats.failures++;
      mutex_unlock(&domain->mutex);
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate %zu buffer bytes", charge);
    }
    memset(node, 0, sizeof(*node));
    node->allocation = node;
    uintptr_t start = (uintptr_t)(node + 1) + sizeof(buffer_header_t *);
    node->data = (void *)((start + alignment - 1) & ~(uintptr_t)(alignment - 1));
    ((buffer_header_t **)node->data)[-1] = node;
    node->domain = domain;
    node->capacity = capacity;
    node->charge = charge;
    node->alignment = alignment;
    node->bin = bin;
    domain->stats.reserved_bytes += charge;
    domain->stats.allocations++;
  }
  node->next = NULL;
  BUFFER_UNPOISON(node->data, node->capacity);
  atomic_store_u64(&node->references, 1);
  node->length = size;
  domain->stats.outstanding++;
  domain->stats.live_bytes += node->charge;
  domain->stats.requested_bytes += size;
  if (domain->stats.reserved_bytes > domain->stats.peak_bytes)
    domain->stats.peak_bytes = domain->stats.reserved_bytes;
  *out = node->data;
  mutex_unlock(&domain->mutex);
  return ASCIICHAT_OK;
}

References buffer_header::alignment, ALLOC_MALLOC, buffer_header::allocation, buffer_stats_t::allocations, ASCIICHAT_OK, buffer_header::bin, buffer_domain::bins, BUFFER_BINS, BUFFER_DEFAULT_ALIGNMENT, buffer_default_domain(), BUFFER_MAX_CACHED, BUFFER_MIN_CAPACITY, BUFFER_UNPOISON, buffer_stats_t::cached_bytes, buffer_header::capacity, buffer_header::charge, buffer_domain::closing, buffer_domain::config, buffer_domain_config_t::control, buffer_header::data, buffer_header::domain, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEMORY, buffer_stats_t::failures, buffer_stats_t::hits, buffer_header::length, buffer_domain_config_t::limit_bytes, buffer_stats_t::live_bytes, buffer_domain::mutex, buffer_header::next, out, buffer_stats_t::outstanding, buffer_stats_t::peak_bytes, buffer_header::references, buffer_stats_t::requested_bytes, buffer_stats_t::reserved_bytes, SET_ERRNO, and buffer_domain::stats.

Referenced by buffer_alloc(), and buffer_workspace_reserve().

buffer_alloc()

void * buffer_alloc	(	buffer_domain_t *	domain,
		size_t	size )

Convenience for typed C callers; failures set asciichat_errno and return NULL.

Definition at line 274 of file buffer.c.

                                                         {
  void *data = NULL;
  (void)buffer_acquire(domain, size, BUFFER_DEFAULT_ALIGNMENT, &data);
  return data;
}

References buffer_acquire(), and BUFFER_DEFAULT_ALIGNMENT.

Referenced by acip_async_tcp_client_create(), acip_packet_encrypt(), acip_packet_seal(), acip_send_audio_batch(), acip_send_audio_opus_batch(), acip_send_error(), acip_send_image_frame_h265(), acip_send_remote_log(), av_send_audio_opus_batch(), client_handle_auth_challenge(), client_handle_crypto_parameters(), client_handle_handshake_complete(), client_handle_key_exchange_init(), compress_data(), crypto_record_open_sequence(), crypto_record_seal_into_domain(), framebuffer_peek_latest_multi_frame(), framebuffer_write_frame(), framebuffer_write_multi_frame(), image_new(), mixer_create_channels(), packet_queue_push_copy(), packet_receive(), peer_crypto_receive(), platform_event_stream_write(), quic_datagram_read(), receive_packet_secure_with_timeout(), send_image_frame_packet(), send_packet_secure(), and video_frame_buffer_create().

buffer_budget_release()

void buffer_budget_release

(

buffer_budget_t *

budget

)

Definition at line 88 of file buffer.c.

                                                    {
  if (budget && budget->bytes) {
    atomic_fetch_sub_u64(&process_bytes, budget->bytes);
    budget->bytes = 0;
  }
}

References buffer_budget_t::bytes.

buffer_budget_reserve()

asciichat_error_t buffer_budget_reserve	(	buffer_budget_t *	budget,
		size_t	bytes )

Budget lease for platform storage that cannot be recycled (e.g. pinned mappings). Zero-initialize, reserve before allocation, release only after disposing storage. A failed reservation preserves the lease. Never copy a live lease.

Definition at line 79 of file buffer.c.

                                                                               {
  if (!budget || budget->bytes || !bytes)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Expected an empty buffer budget lease");
  if (!process_reserve(bytes, false))
    return SET_ERRNO(ERROR_MEMORY, "Process buffer budget exhausted reserving platform storage");
  budget->bytes = bytes;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, buffer_budget_t::bytes, ERROR_INVALID_PARAM, ERROR_MEMORY, and SET_ERRNO.

buffer_capacity()

size_t buffer_capacity

(

const void *

data

)

Query only a live owning payload pointer (NULL returns zero).

Definition at line 280 of file buffer.c.

                                         {
  return data ? header(data)->capacity : 0;
}

Referenced by buffer_set_size(), buffer_workspace_reserve(), compress_workspace(), manpage_content_generate_environment(), manpage_content_generate_environment_with_manual(), manpage_content_generate_examples(), manpage_content_generate_options(), manpage_content_generate_positional(), manpage_content_generate_usage(), manpage_merger_generate_usage(), packet_decode_frame_data_workspace(), packet_decrypt_envelope(), packet_queue_push_shared(), packet_queue_push_take(), packet_receive_via_transport(), quic_connection_submit_datagram(), and quic_datagram_read().

buffer_control_domain()

buffer_domain_t * buffer_control_domain

(

void

)

Small, bounded control messages may use the reserved process allowance.

Definition at line 436 of file buffer.c.

                                             {
  buffer_system_init();
  return control_domain;
}

References buffer_system_init().

Referenced by acip_packet_plan(), acip_send_error(), crypto_record_seal_into_domain(), packet_receive(), stats_logger_thread(), and websocket_transport_send().

buffer_default_domain()

buffer_domain_t * buffer_default_domain

(

void

)

Definition at line 423 of file buffer.c.

                                             {
  buffer_system_init();
  return default_domain;
}

References buffer_system_init().

Referenced by buffer_acquire(), and stats_logger_thread().

buffer_domain_close()

void buffer_domain_close

(

buffer_domain_t **

domain

)

Stop admissions and trim cached storage. Outstanding buffers keep the domain alive. Join users of the domain pointer before closing; outstanding payloads may be released afterwards, from any thread. Clears the caller's domain pointer.

Definition at line 156 of file buffer.c.

                                                 {
  if (!slot || !*slot)
    return;
  buffer_domain_t *domain = *slot;
  *slot = NULL;
  mutex_lock(&domain->mutex);
  domain->closing = true;
  trim_locked(domain, true);
  bool done = domain->stats.outstanding == 0;
  mutex_unlock(&domain->mutex);
  if (done)
    domain_dispose(domain);
}

References buffer_domain::closing, buffer_domain::mutex, buffer_stats_t::outstanding, and buffer_domain::stats.

Referenced by buffer_system_cleanup(), buffer_system_init(), and packet_queue_destroy().

buffer_domain_create()

asciichat_error_t buffer_domain_create	(	const buffer_domain_config_t *	config,
		buffer_domain_t **	out )

Create a domain under the shared process budget.

Definition at line 125 of file buffer.c.

                                                                                                    {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Buffer domain output is NULL");
  *out = NULL;
  buffer_domain_config_t defaults = {BUFFER_DOMAIN_LIMIT, 32 * 1024 * 1024, 5000000000ULL, false};
  if (!process_reserve(sizeof(buffer_domain_t), config && config->control))
    return SET_ERRNO(ERROR_MEMORY, "Process buffer budget exhausted creating domain");
  buffer_domain_t *domain = ALLOC_CALLOC(1, sizeof(*domain));
  if (!domain) {
    atomic_fetch_sub_u64(&process_bytes, sizeof(*domain));
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate buffer domain");
  }
  domain->config = config ? *config : defaults;
  if (!domain->config.limit_bytes)
    domain->config.limit_bytes = BUFFER_DOMAIN_LIMIT;
  if (mutex_init(&domain->mutex,
                 domain->config.control ? "reserved_control_buffer_pool" : "shared_media_buffer_pool") != 0) {
    atomic_fetch_sub_u64(&process_bytes, sizeof(*domain));
    SAFE_FREE(domain);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize buffer domain mutex");
  }
  *out = domain;
  return ASCIICHAT_OK;
}

References ALLOC_CALLOC, ASCIICHAT_OK, BUFFER_DOMAIN_LIMIT, buffer_domain::config, buffer_domain_config_t::control, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_THREAD, buffer_domain_config_t::limit_bytes, buffer_domain::mutex, out, SAFE_FREE, and SET_ERRNO.

Referenced by buffer_system_init(), and packet_queue_create_config().

buffer_domain_log_stats()

void buffer_domain_log_stats	(	buffer_domain_t *	domain,
		const char *	name )

Definition at line 392 of file buffer.c.

                                                                        {
  buffer_stats_t stats;
  buffer_domain_stats(domain, &stats);
  log_debug("Buffers %s: reserved=%zu live=%zu requested=%zu cached=%zu outstanding=%zu hits=%llu failures=%llu",
            name ? name : "default", stats.reserved_bytes, stats.live_bytes, stats.requested_bytes, stats.cached_bytes,
            stats.outstanding, (unsigned long long)stats.hits, (unsigned long long)stats.failures);
}

References buffer_domain_stats(), buffer_stats_t::cached_bytes, buffer_stats_t::failures, buffer_stats_t::hits, buffer_stats_t::live_bytes, log_debug, buffer_stats_t::outstanding, buffer_stats_t::requested_bytes, and buffer_stats_t::reserved_bytes.

Referenced by stats_logger_thread().

buffer_domain_stats()

void buffer_domain_stats	(	buffer_domain_t *	domain,
		buffer_stats_t *	out )

Definition at line 381 of file buffer.c.

                                                                       {
  if (!out)
    return;
  memset(out, 0, sizeof(*out));
  if (!domain)
    return;
  mutex_lock(&domain->mutex);
  *out = domain->stats;
  mutex_unlock(&domain->mutex);
}

References buffer_domain::mutex, out, and buffer_domain::stats.

Referenced by buffer_domain_log_stats().

buffer_domain_trim()

void buffer_domain_trim

(

buffer_domain_t *

domain

)

Maintenance operation; never called implicitly from the steady-state release path.

Definition at line 170 of file buffer.c.

                                                 {
  if (!domain)
    return;
  mutex_lock(&domain->mutex);
  trim_locked(domain, false);
  mutex_unlock(&domain->mutex);
}

References buffer_domain::mutex.

Referenced by stats_logger_thread().

buffer_is_unique()

bool buffer_is_unique

(

const void *

data

)

Test exclusive ownership while retaining a reference. Only the owner may publish new references while using this result to modify/recycle storage.

Definition at line 317 of file buffer.c.

                                        {
  return data && atomic_load_u64(&header(data)->references) == 1;
}

Referenced by packet_decrypt_envelope().

buffer_process_reserved()

size_t buffer_process_reserved

(

void

)

Definition at line 75 of file buffer.c.

                                     {
  return (size_t)atomic_load_u64(&process_bytes);
}

buffer_set_size()

asciichat_error_t buffer_set_size	(	void *	data,
		size_t	size )

Change logical length within capacity. Requires exclusive ownership.

Definition at line 287 of file buffer.c.

                                                           {
  if (!data || size > buffer_capacity(data))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Buffer length exceeds capacity");
  buffer_header_t *node = header(data);
  buffer_domain_t *domain = node->domain;
  mutex_lock(&domain->mutex);
  if (atomic_load_u64(&node->references) != 1) {
    mutex_unlock(&domain->mutex);
    return SET_ERRNO(ERROR_INVALID_STATE, "Cannot resize shared buffer");
  }
  domain->stats.requested_bytes -= node->length;
  node->length = size;
  domain->stats.requested_bytes += size;
  mutex_unlock(&domain->mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, buffer_capacity(), buffer_header::domain, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, buffer_header::length, buffer_domain::mutex, buffer_header::references, buffer_stats_t::requested_bytes, SET_ERRNO, and buffer_domain::stats.

Referenced by compress_workspace().

buffer_share()

const void * buffer_share

(

const void *

data

)

Acquire another immutable reference while an existing reference is held.

Definition at line 304 of file buffer.c.

                                           {
  if (!data)
    return NULL;
  buffer_header_t *node = header(data);
  uint64_t references = atomic_load_u64(&node->references);
  while (references && references != SIZE_MAX) {
    if (atomic_cas_u64(&node->references, &references, references + 1))
      return data;
  }
  SET_ERRNO(ERROR_INVALID_STATE, "Invalid buffer reference count");
  return NULL;
}

References ERROR_INVALID_STATE, buffer_header::references, and SET_ERRNO.

Referenced by packet_queue_push_shared().

buffer_size()

size_t buffer_size

(

const void *

data

)

Definition at line 283 of file buffer.c.

                                     {
  return data ? header(data)->length : 0;
}

buffer_system_cleanup()

void buffer_system_cleanup

(

void

)

Definition at line 428 of file buffer.c.

                                 {
  if (lifecycle_shutdown(&default_lifecycle)) {
    NAMED_UNREGISTER(&process_bytes);
    buffer_domain_close(&default_domain);
    buffer_domain_close(&control_domain);
  }
}

References buffer_domain_close(), and NAMED_UNREGISTER.

Referenced by asciichat_shared_destroy(), and mirror_cleanup().

buffer_system_init()

void buffer_system_init

(

void

)

Application startup/shutdown, serialized against starting/stopping workers.

Definition at line 400 of file buffer.c.

                              {
  for (;;) {
    if (lifecycle_init_once(&default_lifecycle))
      break;
    if (lifecycle_is_initialized(&default_lifecycle) || lifecycle_is_dead(&default_lifecycle))
      return;
    // Another caller must finish publishing both domains before allocations use them.
    platform_sleep_us(100);
  }
  if (buffer_domain_create(NULL, &default_domain) != ASCIICHAT_OK) {
    lifecycle_init_abort(&default_lifecycle);
    return;
  }
  buffer_domain_config_t control = {BUFFER_CONTROL_RESERVE, 1024 * 1024, 5000000000ULL, true};
  if (buffer_domain_create(&control, &control_domain) != ASCIICHAT_OK) {
    buffer_domain_close(&default_domain);
    lifecycle_init_abort(&default_lifecycle);
    return;
  }
  NAMED_REGISTER_ATOMIC(&process_bytes, "buffer.process_reserved_bytes", NULL);
  lifecycle_init_commit(&default_lifecycle);
}

References ASCIICHAT_OK, BUFFER_CONTROL_RESERVE, buffer_domain_close(), buffer_domain_create(), and NAMED_REGISTER_ATOMIC.

Referenced by asciichat_shared_init(), buffer_control_domain(), and buffer_default_domain().

buffer_unref()

void buffer_unref

(

const void *

data

)

Low-level release for ownership passed by value. Prefer buffer_release().

Definition at line 321 of file buffer.c.

                                    {
  if (!data)
    return;
  buffer_header_t *node = header(data);
  buffer_domain_t *domain = node->domain;
  uint64_t references = atomic_load_u64(&node->references);
  while (references && !atomic_cas_u64(&node->references, &references, references - 1)) {
  }
  if (!references) {
    SET_ERRNO(ERROR_INVALID_STATE, "Buffer has already been released");
    return;
  }
  if (references > 1) {
    return;
  }
  mutex_lock(&domain->mutex);
  domain->stats.outstanding--;
  domain->stats.live_bytes -= node->charge;
  domain->stats.requested_bytes -= node->length;
  bool done = domain->closing && !domain->stats.outstanding;
  if (!domain->closing && node->capacity <= BUFFER_MAX_CACHED && node->charge <= domain->config.cache_bytes &&
      domain->stats.cached_bytes <= domain->config.cache_bytes - node->charge) {
    node->returned_at = time_get_ns();
    BUFFER_POISON(node->data, node->capacity);
    node->next = domain->bins[node->bin];
    domain->bins[node->bin] = node;
    domain->stats.cached_bytes += node->charge;
  } else {
    dispose(domain, node);
  }
  mutex_unlock(&domain->mutex);
  if (done)
    domain_dispose(domain);
}

References buffer_header::bin, buffer_domain::bins, BUFFER_MAX_CACHED, BUFFER_POISON, buffer_domain_config_t::cache_bytes, buffer_stats_t::cached_bytes, buffer_header::capacity, buffer_header::charge, buffer_domain::closing, buffer_domain::config, buffer_header::data, buffer_header::domain, ERROR_INVALID_STATE, buffer_header::length, buffer_stats_t::live_bytes, buffer_domain::mutex, buffer_header::next, buffer_stats_t::outstanding, buffer_header::references, buffer_stats_t::requested_bytes, buffer_header::returned_at, SET_ERRNO, and buffer_domain::stats.

buffer_workspace_destroy()

void buffer_workspace_destroy

(

buffer_workspace_t *

workspace

)

Definition at line 374 of file buffer.c.

                                                             {
  if (workspace) {
    buffer_release(workspace->data);
    workspace->length = 0;
  }
}

References buffer_release, buffer_workspace_t::data, and buffer_workspace_t::length.

Referenced by compression_workspace_destroy().

buffer_workspace_reserve()

asciichat_error_t buffer_workspace_reserve	(	buffer_workspace_t *	workspace,
		buffer_domain_t *	domain,
		size_t	capacity )

Preserves the previous workspace on failure; retains capacity between frames.

Definition at line 356 of file buffer.c.

                                                                                                                    {
  if (!workspace)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Workspace is NULL");
  if (workspace->length > buffer_capacity(workspace->data))
    return SET_ERRNO(ERROR_INVALID_STATE, "Workspace length exceeds its storage");
  if (capacity <= buffer_capacity(workspace->data))
    return ASCIICHAT_OK;
  void *next = NULL;
  asciichat_error_t result = buffer_acquire(domain, capacity, BUFFER_DEFAULT_ALIGNMENT, &next);
  if (result != ASCIICHAT_OK)
    return result;
  if (workspace->data && workspace->length)
    memcpy(next, workspace->data, workspace->length);
  buffer_release(workspace->data);
  workspace->data = next;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, buffer_acquire(), buffer_capacity(), BUFFER_DEFAULT_ALIGNMENT, buffer_release, buffer_workspace_t::data, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, buffer_workspace_t::length, and SET_ERRNO.

Referenced by compress_workspace(), packet_decode_frame_data_workspace(), packet_decoder_feed(), and threaded_send_image_frame_encoded().