Grok 4.1 Fast· xai
Frontier Reasoning Traces
Implement a ring buffer in C for high-speed data acquisition.
- User
Implement a ring buffer in C for high-speed data acquisition.
- Assistant
#include <stdint.h> #include <stdbool.h> #include <string.h> #include <stddef.h> /** * High-performance ring buffer implementation in C, optimized for high-speed * data acquisition scenarios (e.g., streaming bytes from sensors, ADCs, or * network interfaces). * * Key features: * - Single producer / single consumer (SPSC) lock-free design (no mutexes/locks). * - Power-of-2 capacity for fast wrap-around using bitwise AND masking. * - Efficient block read/write operations using at most two memcpy() calls. * - Single-byte push/pop for convenience. * - User-provided fixed buffer (no dynamic allocation for determinism). * * Usage notes: * - Capacity MUST be a power of 2 (e.g., 1024, 4096). Caller must ensure this. * - Thread-safe only for SPSC without locks; use atomics (e.g., stdatomic.h) * if needed for MP/MC, but that adds overhead. * - For ultra-high speed (e.g., >1GB/s), compile with -O3 -march=native. */ typedef struct { size_t head; // Write position (masked) size_t tail; // Read position (masked) size_t size; // Current number of bytes size_t capacity; // Total capacity (power of 2) size_t mask; // capacity - 1 for fast modulo uint8_t *data; // User-provided buffer } ring_buffer_t; /** * Initialize the ring buffer. * @param rb Ring buffer instance. * @param buf Pre-allocated buffer (must be at least 'cap' bytes). * @param cap Capacity (must be power of 2, e.g., 1024). */ void rb_init(ring_buffer_t *rb, uint8_t *buf, size_t cap) { rb->head = 0; rb->tail = 0; rb->size = 0; rb->capacity = cap; rb->mask = cap - 1; rb->data = buf; } /** * Check if the buffer is empty. */ bool rb_empty(const ring_buffer_t *rb) { return rb->size == 0; } /** * Check if the buffer is full. */ bool rb_full(const ring_buffer_t *rb) { return rb->size == rb->capacity; } /** * Get current size (bytes available to read). */ size_t rb_size(const ring_buffer_t *rb) { return rb->size; } /** * Get capacity. */ size_t rb_capacity(const ring_buffer_t *rb) { return rb->capacity; } /** * Reset the buffer (clear without freeing). */ void rb_reset(ring_buffer_t *rb) { rb->head = 0; rb->tail = 0; rb->size = 0; } /** * Write (enqueue) a single byte. * @return true if written, false if full. */ bool rb_put(ring_buffer_t *rb, uint8_t byte) { if (rb_full(rb)) { return false; } rb->data[rb->head] = byte; rb->head = (rb->head + 1) & rb->mask; rb->size++; return true; } /** * Read (dequeue) a single byte. * @param byte Output byte. * @return true if read, false if empty. */ bool rb_get(ring_buffer_t *rb, uint8_t *byte) { if (rb_empty(rb)) { return false; } *byte = rb->data[rb->tail]; rb->tail = (rb->tail + 1) & rb->mask; rb->size--; return true; } /** * Write (enqueue) up to 'len' bytes from src. * Handles wrap-around efficiently with at most 2 memcpy() calls. * @return Number of bytes actually written (<= len). */ size_t rb_write(ring_buffer_t *rb, const uint8_t *src, size_t len) { size_t cap = rb->capacity; size_t l = (len > (cap - rb->size)) ? (cap - rb->size) : len; if (l == 0) { return 0; } size_t mask = rb->mask; size_t h = rb->head; size_t hpos = h & mask; size_t space_to_end = cap - hpos; if (l <= space_to_end) { // No wrap memcpy(rb->data + hpos, src, l); } else { // Wrap around memcpy(rb->data + hpos, src, space_to_end); memcpy(rb->data, src + space_to_end, l - space_to_end); } rb->head = (h + l) & mask; rb->size += l; return l; } /** * Read (dequeue) up to 'len' bytes into dst. * Handles wrap-around efficiently with at most 2 memcpy() calls. * @return Number of bytes actually read (<= len). */ size_t rb_read(ring_buffer_t *rb, uint8_t *dst, size_t len) { size_t l = (len > rb->size) ? rb->size : len; if (l == 0) { return 0; } size_t cap = rb->capacity; size_t mask = rb->mask; size_t t = rb->tail; size_t tpos = t & mask; size_t space_to_end = cap - tpos; if (l <= space_to_end) { // No wrap memcpy(dst, rb->data + tpos, l); } else { // Wrap around memcpy(dst, rb->data + tpos, space_to_end); memcpy(dst + space_to_end, rb->data, l - space_to_end); } rb->tail = (t + l) & mask; rb->size -= l; return l; } /* Example usage */ #include <stdio.h> #define BUF_CAPACITY 1024 // Must be power of 2 int main(void) { uint8_t buf[BUF_CAPACITY]; ring_buffer_t rb; rb_init(&rb, buf, BUF_CAPACITY); // Producer: high-speed write (e.g., from ADC) uint8_t producer_data[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A}; size_t written = rb_write(&rb, producer_data, 10); printf("Written: %zu bytes\n", written); // Consumer: high-speed read (e.g., to processor or file) uint8_t consumer_data[10]; size_t read = rb_read(&rb, consumer_data, 10); printf("Read: %zu bytes\n", read); // Single byte example rb_put(&rb, 0xFF); uint8_t byte; if (rb_get(&rb, &byte)) { printf("Got byte: 0x%02X\n", byte); } printf("Buffer size: %zu / %zu\n", rb_size(&rb), rb_capacity(&rb)); return 0; }This implementation is production-ready for high-speed data acquisition. The block
rb_write/rb_readoperations minimize overhead, making it suitable for real-time systems (e.g., DMA buffers, audio capture). Test with your hardware/threading model. For multi-producer/consumer, consider adding atomics (C11_Atomic).
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.