Data-Buffer-Shared
view release on metacpan or search on metacpan
buf_generic.h view on Meta::CPAN
#ifndef BUF_DEFS_H
#define BUF_DEFS_H
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/syscall.h>
#include <limits.h>
#include <signal.h>
#include <errno.h>
#include <linux/futex.h>
#include <sys/eventfd.h>
#include <pthread.h>
/* ---- Constants ---- */
#define BUF_MAGIC 0x42554631U /* "BUF1" */
#define BUF_VERSION 2 /* v2: reader-slot table for dead-reader rwlock recovery */
#define BUF_ERR_BUFLEN 256
#define BUF_READER_SLOTS 1024 /* per-process reader-counter mirror */
/* ---- Per-process reader-slot table (in shared memory) ----
* Mirrors each process's contribution to the global rwlock counters so a
* dead reader's contribution can be reclaimed on writer-lock timeout. */
typedef struct {
uint32_t pid; /* owning PID, 0 = free */
uint32_t subcount; /* this process's rwlock reader contribution */
uint32_t waiters_parked; /* this process's contribution to rwlock_waiters */
uint32_t writers_parked; /* this process's contribution to rwlock_writers_waiting */
} BufReaderSlot;
/* ---- Shared memory header (128 bytes, 2 cache lines, in mmap) ---- */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#define BUF_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
#else
#define BUF_STATIC_ASSERT(cond, msg)
#endif
typedef struct {
/* ---- Cache line 0 (0-63): immutable after create ---- */
uint32_t magic; /* 0 */
uint32_t version; /* 4 */
uint32_t variant_id; /* 8 */
uint32_t elem_size; /* 12 */
uint64_t capacity; /* 16: number of elements */
uint64_t total_size; /* 24: total mmap size */
uint64_t data_off; /* 32: offset to data array */
uint64_t reader_slots_off;/* 40: offset to BufReaderSlot[BUF_READER_SLOTS] */
uint8_t _reserved0[16]; /* 48-63 */
/* ---- Cache line 1 (64-127): seqlock + rwlock + mutable state ---- */
uint32_t seq; /* 64: seqlock counter, odd = writer active */
uint32_t rwlock; /* 68: 0=unlocked, readers=1..0x7FFFFFFF, writer=0x80000000|pid */
uint32_t rwlock_waiters; /* 72: wake-target counter (readers+writers) */
uint32_t stat_recoveries; /* 76 */
uint32_t rwlock_writers_waiting; /* 80: reader yield signal (writers only) */
uint32_t _pad2; /* 84 */
uint64_t _reserved1[5]; /* 88-127 */
} BufHeader;
BUF_STATIC_ASSERT(sizeof(BufHeader) == 128, "BufHeader must be exactly 128 bytes (2 cache lines)");
/* ---- Process-local handle ---- */
typedef struct {
BufHeader *hdr;
void *data; /* pointer to element array in mmap */
BufReaderSlot *reader_slots; /* in mmap, BUF_READER_SLOTS entries */
size_t mmap_size;
char *path; /* backing file path (strdup'd, NULL for anon) */
int fd; /* kept open for memfd, -1 otherwise */
int efd; /* eventfd for notifications, -1 if none */
uint32_t my_slot_idx; /* UINT32_MAX = unclaimed; per-process slot index */
uint32_t cached_pid; /* getpid() at claim time */
uint32_t cached_fork_gen; /* fork-generation at claim time */
uint8_t wr_locked; /* process-local: 1 if lock_wr is held */
uint8_t efd_owned; /* 1 if we created the eventfd (close on destroy) */
} BufHandle;
/* ---- Futex-based read-write lock ---- */
#define BUF_RWLOCK_SPIN_LIMIT 32
#define BUF_LOCK_TIMEOUT_SEC 2
static inline void buf_spin_pause(void) {
#if defined(__x86_64__) || defined(__i386__)
__asm__ volatile("pause" ::: "memory");
#elif defined(__aarch64__)
__asm__ volatile("yield" ::: "memory");
#else
__asm__ volatile("" ::: "memory");
#endif
}
#define BUF_RWLOCK_WRITER_BIT 0x80000000U
#define BUF_RWLOCK_PID_MASK 0x7FFFFFFFU
#define BUF_RWLOCK_WR(pid) (BUF_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & BUF_RWLOCK_PID_MASK))
static inline int buf_pid_alive(uint32_t pid) {
if (pid == 0) return 1;
return !(kill((pid_t)pid, 0) == -1 && errno == ESRCH);
}
/* ---- Per-process slot lifecycle (dead-reader recovery) ----
* Each process claims one BufReaderSlot lazily on first lock op so that
* its contribution to the shared rwlock counter can be reclaimed by other
* processes if it dies (SIGKILL'd worker no longer pins the counter). */
static uint32_t buf_fork_gen = 0;
static pthread_once_t buf_atfork_once = PTHREAD_ONCE_INIT;
static void buf_on_fork_child(void) {
__atomic_add_fetch(&buf_fork_gen, 1, __ATOMIC_RELAXED);
}
static void buf_atfork_init(void) {
pthread_atfork(NULL, NULL, buf_on_fork_child);
}
static inline void buf_claim_reader_slot(BufHandle *h) {
if (!h->reader_slots) return;
pthread_once(&buf_atfork_once, buf_atfork_init);
uint32_t cur_gen = __atomic_load_n(&buf_fork_gen, __ATOMIC_RELAXED);
if (h->cached_fork_gen != cur_gen) {
h->cached_fork_gen = cur_gen;
h->my_slot_idx = UINT32_MAX;
}
if (h->my_slot_idx != UINT32_MAX) return;
uint32_t now_pid = (uint32_t)getpid();
h->cached_pid = now_pid;
uint32_t start = now_pid % BUF_READER_SLOTS;
for (uint32_t i = 0; i < BUF_READER_SLOTS; i++) {
uint32_t s = (start + i) % BUF_READER_SLOTS;
uint32_t expected = 0;
if (__atomic_compare_exchange_n(&h->reader_slots[s].pid,
&expected, now_pid, 0,
__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_store_n(&h->reader_slots[s].subcount, 0, __ATOMIC_RELAXED);
__atomic_store_n(&h->reader_slots[s].waiters_parked, 0, __ATOMIC_RELAXED);
buf_generic.h view on Meta::CPAN
* ================================================================ */
#ifndef BUF_PREFIX
#error "BUF_PREFIX must be defined before including buf_generic.h"
#endif
#define BUF_PASTE2(a, b) a##_##b
#define BUF_PASTE(a, b) BUF_PASTE2(a, b)
#define BUF_FN(name) BUF_PASTE(BUF_PREFIX, name)
/* ---- Create ---- */
#ifdef BUF_IS_FIXEDSTR
static BufHandle *BUF_FN(create)(const char *path, uint64_t capacity,
uint32_t str_len, char *errbuf) {
if (str_len == 0) {
snprintf(errbuf, BUF_ERR_BUFLEN, "str_len must be > 0");
return NULL;
}
return buf_create_map(path, capacity, str_len, BUF_VARIANT_ID, errbuf);
}
#else
static BufHandle *BUF_FN(create)(const char *path, uint64_t capacity, char *errbuf) {
return buf_create_map(path, capacity, BUF_ELEM_SIZE, BUF_VARIANT_ID, errbuf);
}
#endif
/* ---- Create anonymous ---- */
#ifdef BUF_IS_FIXEDSTR
static BufHandle *BUF_FN(create_anon)(uint64_t capacity, uint32_t str_len, char *errbuf) {
if (str_len == 0) { snprintf(errbuf, BUF_ERR_BUFLEN, "str_len must be > 0"); return NULL; }
return buf_create_anon(capacity, str_len, BUF_VARIANT_ID, errbuf);
}
static BufHandle *BUF_FN(create_memfd)(const char *name, uint64_t capacity, uint32_t str_len, char *errbuf) {
if (str_len == 0) { snprintf(errbuf, BUF_ERR_BUFLEN, "str_len must be > 0"); return NULL; }
return buf_create_memfd(name, capacity, str_len, BUF_VARIANT_ID, errbuf);
}
static BufHandle *BUF_FN(open_fd)(int fd, uint32_t str_len, char *errbuf) {
if (str_len == 0) { snprintf(errbuf, BUF_ERR_BUFLEN, "str_len must be > 0"); return NULL; }
return buf_open_fd(fd, str_len, BUF_VARIANT_ID, errbuf);
}
#else
static BufHandle *BUF_FN(create_anon)(uint64_t capacity, char *errbuf) {
return buf_create_anon(capacity, BUF_ELEM_SIZE, BUF_VARIANT_ID, errbuf);
}
static BufHandle *BUF_FN(create_memfd)(const char *name, uint64_t capacity, char *errbuf) {
return buf_create_memfd(name, capacity, BUF_ELEM_SIZE, BUF_VARIANT_ID, errbuf);
}
static BufHandle *BUF_FN(open_fd)(int fd, char *errbuf) {
return buf_open_fd(fd, BUF_ELEM_SIZE, BUF_VARIANT_ID, errbuf);
}
#endif
/* ---- Raw byte access (for packed binary interop) ---- */
static int BUF_FN(get_raw)(BufHandle *h, uint64_t byte_off, uint64_t nbytes, void *out) {
uint64_t data_size = h->hdr->capacity * (uint64_t)h->hdr->elem_size;
if (nbytes > data_size || byte_off > data_size - nbytes) return 0;
char *data = (char *)h->data;
if (h->wr_locked) {
memcpy(out, data + byte_off, (size_t)nbytes);
} else {
uint32_t seq_start;
do {
seq_start = buf_seqlock_read_begin(h->hdr);
memcpy(out, data + byte_off, (size_t)nbytes);
} while (buf_seqlock_read_retry(&h->hdr->seq, seq_start));
}
return 1;
}
static int BUF_FN(set_raw)(BufHandle *h, uint64_t byte_off, uint64_t nbytes, const void *in) {
uint64_t data_size = h->hdr->capacity * (uint64_t)h->hdr->elem_size;
if (nbytes > data_size || byte_off > data_size - nbytes) return 0;
char *data = (char *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&h->hdr->seq); }
memcpy(data + byte_off, in, (size_t)nbytes);
if (!nested) { buf_seqlock_write_end(&h->hdr->seq); buf_rwlock_wrunlock(h); }
return 1;
}
/* ---- Clear (zero entire buffer) ---- */
static void BUF_FN(clear)(BufHandle *h) {
BufHeader *hdr = h->hdr;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
memset(h->data, 0, (size_t)(hdr->capacity * hdr->elem_size));
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
}
/* ---- Single-element atomic get (lock-free for numeric types) ---- */
#ifdef BUF_IS_FIXEDSTR
static int BUF_FN(get)(BufHandle *h, uint64_t idx, char *out, uint32_t *out_len) {
BufHeader *hdr = h->hdr;
uint32_t esz = hdr->elem_size;
if (idx >= hdr->capacity) return 0;
char *data = (char *)h->data;
if (h->wr_locked) {
memcpy(out, data + idx * esz, esz);
} else {
uint32_t seq_start;
do {
seq_start = buf_seqlock_read_begin(hdr);
memcpy(out, data + idx * esz, esz);
} while (buf_seqlock_read_retry(&hdr->seq, seq_start));
}
uint32_t len = esz;
while (len > 0 && out[len - 1] == '\0') len--;
*out_len = len;
return 1;
}
static int BUF_FN(set)(BufHandle *h, uint64_t idx, const char *val, uint32_t len) {
BufHeader *hdr = h->hdr;
uint32_t esz = hdr->elem_size;
if (idx >= hdr->capacity) return 0;
char *data = (char *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
memset(data + idx * esz, 0, esz);
uint32_t copy_len = len < esz ? len : esz;
memcpy(data + idx * esz, val, copy_len);
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
return 1;
}
#elif defined(BUF_IS_FLOAT)
/* Float/double: GCC __atomic builtins don't support FP types.
* Use same-sized integer atomic load/store + memcpy for lock-free access. */
#if BUF_ELEM_SIZE == 4
typedef uint32_t BUF_PASTE(BUF_PREFIX, _uint_t);
#elif BUF_ELEM_SIZE == 8
typedef uint64_t BUF_PASTE(BUF_PREFIX, _uint_t);
#else
#error "BUF_IS_FLOAT requires BUF_ELEM_SIZE of 4 or 8"
#endif
static int BUF_FN(get)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE *out) {
BufHeader *hdr = h->hdr;
if (idx >= hdr->capacity) return 0;
typedef BUF_PASTE(BUF_PREFIX, _uint_t) uint_t;
uint_t *idata = (uint_t *)h->data;
uint_t tmp = __atomic_load_n(&idata[idx], __ATOMIC_RELAXED);
memcpy(out, &tmp, sizeof(BUF_ELEM_TYPE));
return 1;
}
static int BUF_FN(set)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE val) {
BufHeader *hdr = h->hdr;
if (idx >= hdr->capacity) return 0;
typedef BUF_PASTE(BUF_PREFIX, _uint_t) uint_t;
uint_t *idata = (uint_t *)h->data;
uint_t tmp;
memcpy(&tmp, &val, sizeof(BUF_ELEM_TYPE));
__atomic_store_n(&idata[idx], tmp, __ATOMIC_RELAXED);
return 1;
}
#else /* integer types */
static int BUF_FN(get)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE *out) {
BufHeader *hdr = h->hdr;
if (idx >= hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
*out = __atomic_load_n(&data[idx], __ATOMIC_RELAXED);
return 1;
}
static int BUF_FN(set)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE val) {
BufHeader *hdr = h->hdr;
if (idx >= hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
__atomic_store_n(&data[idx], val, __ATOMIC_RELAXED);
return 1;
}
#endif /* BUF_IS_FIXEDSTR */
/* ---- Bulk operations (seqlock-guarded) ---- */
#ifdef BUF_IS_FIXEDSTR
static int BUF_FN(get_slice)(BufHandle *h, uint64_t from, uint64_t count,
void *out) {
BufHeader *hdr = h->hdr;
uint32_t esz = hdr->elem_size;
if (count > hdr->capacity || from > hdr->capacity - count) return 0;
char *data = (char *)h->data;
if (h->wr_locked) {
memcpy(out, data + from * esz, count * esz);
} else {
uint32_t seq_start;
do {
seq_start = buf_seqlock_read_begin(hdr);
memcpy(out, data + from * esz, count * esz);
} while (buf_seqlock_read_retry(&hdr->seq, seq_start));
}
return 1;
}
static int BUF_FN(set_slice)(BufHandle *h, uint64_t from, uint64_t count,
const void *in) {
BufHeader *hdr = h->hdr;
uint32_t esz = hdr->elem_size;
if (count > hdr->capacity || from > hdr->capacity - count) return 0;
char *data = (char *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
memcpy(data + from * esz, in, count * esz);
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
return 1;
}
#else /* numeric */
static int BUF_FN(get_slice)(BufHandle *h, uint64_t from, uint64_t count,
BUF_ELEM_TYPE *out) {
BufHeader *hdr = h->hdr;
if (count > hdr->capacity || from > hdr->capacity - count) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
if (h->wr_locked) {
memcpy(out, &data[from], count * sizeof(BUF_ELEM_TYPE));
} else {
uint32_t seq_start;
do {
seq_start = buf_seqlock_read_begin(hdr);
memcpy(out, &data[from], count * sizeof(BUF_ELEM_TYPE));
} while (buf_seqlock_read_retry(&hdr->seq, seq_start));
}
return 1;
}
static int BUF_FN(set_slice)(BufHandle *h, uint64_t from, uint64_t count,
const BUF_ELEM_TYPE *in) {
BufHeader *hdr = h->hdr;
if (count > hdr->capacity || from > hdr->capacity - count) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
memcpy(&data[from], in, count * sizeof(BUF_ELEM_TYPE));
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
return 1;
}
#endif /* BUF_IS_FIXEDSTR */
/* ---- Fill ---- */
#ifdef BUF_IS_FIXEDSTR
static void BUF_FN(fill)(BufHandle *h, const char *val, uint32_t len) {
BufHeader *hdr = h->hdr;
uint32_t esz = hdr->elem_size;
char *data = (char *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
uint32_t copy_len = len < esz ? len : esz;
memset(data, 0, (size_t)hdr->capacity * esz);
for (uint64_t i = 0; i < hdr->capacity; i++)
memcpy(data + i * esz, val, copy_len);
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
}
#else
static void BUF_FN(fill)(BufHandle *h, BUF_ELEM_TYPE val) {
BufHeader *hdr = h->hdr;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
int nested = h->wr_locked;
if (!nested) { buf_rwlock_wrlock(h); buf_seqlock_write_begin(&hdr->seq); }
for (uint64_t i = 0; i < hdr->capacity; i++)
data[i] = val;
if (!nested) { buf_seqlock_write_end(&hdr->seq); buf_rwlock_wrunlock(h); }
}
#endif
/* ---- Atomic operations (integer types only) ---- */
#ifdef BUF_HAS_COUNTERS
static BUF_ELEM_TYPE BUF_FN(incr)(BufHandle *h, uint64_t idx) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_add_fetch(&data[idx], 1, __ATOMIC_RELAXED);
}
static BUF_ELEM_TYPE BUF_FN(decr)(BufHandle *h, uint64_t idx) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_sub_fetch(&data[idx], 1, __ATOMIC_RELAXED);
}
static BUF_ELEM_TYPE BUF_FN(add)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE delta) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_add_fetch(&data[idx], delta, __ATOMIC_RELAXED);
}
static int BUF_FN(cas)(BufHandle *h, uint64_t idx,
BUF_ELEM_TYPE expected, BUF_ELEM_TYPE desired) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_compare_exchange_n(&data[idx], &expected, desired,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);
}
static BUF_ELEM_TYPE BUF_FN(cmpxchg)(BufHandle *h, uint64_t idx,
BUF_ELEM_TYPE expected, BUF_ELEM_TYPE desired) {
if (idx >= h->hdr->capacity) return expected;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
__atomic_compare_exchange_n(&data[idx], &expected, desired,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);
return expected; /* on failure, expected is updated to the current value */
}
static BUF_ELEM_TYPE BUF_FN(atomic_and)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE mask) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_and_fetch(&data[idx], mask, __ATOMIC_RELAXED);
}
static BUF_ELEM_TYPE BUF_FN(atomic_or)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE mask) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_or_fetch(&data[idx], mask, __ATOMIC_RELAXED);
}
static BUF_ELEM_TYPE BUF_FN(atomic_xor)(BufHandle *h, uint64_t idx, BUF_ELEM_TYPE mask) {
if (idx >= h->hdr->capacity) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
return __atomic_xor_fetch(&data[idx], mask, __ATOMIC_RELAXED);
}
static int BUF_FN(add_slice)(BufHandle *h, uint64_t from, uint64_t count,
const BUF_ELEM_TYPE *deltas) {
if (count > h->hdr->capacity || from > h->hdr->capacity - count) return 0;
BUF_ELEM_TYPE *data = (BUF_ELEM_TYPE *)h->data;
for (uint64_t i = 0; i < count; i++)
__atomic_add_fetch(&data[from + i], deltas[i], __ATOMIC_RELAXED);
return 1;
}
#endif /* BUF_HAS_COUNTERS */
/* ---- Diagnostics ---- */
static inline uint64_t BUF_FN(capacity)(BufHandle *h) {
return h->hdr->capacity;
}
static inline uint64_t BUF_FN(mmap_size)(BufHandle *h) {
return (uint64_t)h->mmap_size;
}
static inline uint32_t BUF_FN(elem_size)(BufHandle *h) {
return h->hdr->elem_size;
}
/* ---- Raw pointer access (for passing to external C/XS code) ---- */
static inline void *BUF_FN(ptr)(BufHandle *h) {
return h->data;
}
static inline void *BUF_FN(ptr_at)(BufHandle *h, uint64_t idx) {
if (idx >= h->hdr->capacity) return NULL;
return (char *)h->data + idx * h->hdr->elem_size;
}
/* ---- Explicit locking for batch operations ---- */
static inline void BUF_FN(lock_wr)(BufHandle *h) {
buf_rwlock_wrlock(h);
buf_seqlock_write_begin(&h->hdr->seq);
h->wr_locked = 1;
}
static inline void BUF_FN(unlock_wr)(BufHandle *h) {
h->wr_locked = 0;
buf_seqlock_write_end(&h->hdr->seq);
buf_rwlock_wrunlock(h);
}
static inline void BUF_FN(lock_rd)(BufHandle *h) {
buf_rwlock_rdlock(h);
}
static inline void BUF_FN(unlock_rd)(BufHandle *h) {
buf_rwlock_rdunlock(h);
}
/* ---- Cleanup ---- */
#undef BUF_PASTE2
#undef BUF_PASTE
#undef BUF_FN
#undef BUF_PREFIX
#undef BUF_ELEM_TYPE
#undef BUF_ELEM_SIZE
#undef BUF_VARIANT_ID
#ifdef BUF_HAS_COUNTERS
#undef BUF_HAS_COUNTERS
#endif
#ifdef BUF_IS_FLOAT
#undef BUF_IS_FLOAT
#endif
#ifdef BUF_IS_FIXEDSTR
#undef BUF_IS_FIXEDSTR
#endif
( run in 1.836 second using v1.01-cache-2.11-cpan-e1769b4cff6 )