Data-Sync-Shared
view release on metacpan or search on metacpan
/* Semaphore: value = current count, waiters = blocked acquirers */
/* Barrier: value = arrived count, waiters = blocked at barrier,
generation = increments each time barrier trips */
/* RWLock: value = rwlock word (0=free, N=N readers, 0x80000000|pid=writer),
waiters = blocked lockers */
/* Condvar: value = signal counter (futex word), waiters = blocked waiters,
mutex = associated mutex for predicate protection */
/* Once: value = state (0=INIT, 1=RUNNING|pid, 2=DONE),
waiters = blocked on completion */
uint32_t value; /* 64: primary state word (futex target) */
uint32_t waiters; /* 68: waiter count */
uint32_t generation; /* 72: barrier generation / condvar epoch */
uint32_t mutex; /* 76: condvar mutex (0 or PID|0x80000000) */
uint32_t mutex_waiters; /* 80: condvar mutex waiter count */
uint32_t stat_recoveries;/* 84 */
uint64_t stat_acquires; /* 88 */
uint64_t stat_releases; /* 96 */
uint64_t stat_waits; /* 104 */
uint64_t stat_timeouts; /* 112 */
uint32_t stat_signals; /* 120 */
uint32_t rwlock_writers_waiting; /* 124: RWLock write-preferring yield signal
(writers only, not readers) */
} SyncHeader;
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
_Static_assert(sizeof(SyncHeader) == 128, "SyncHeader must be 128 bytes");
#endif
/* ================================================================
* Process-local handle
* ================================================================ */
typedef struct {
SyncHeader *hdr;
size_t mmap_size;
char *path;
int notify_fd; /* eventfd, -1 if disabled */
int backing_fd; /* memfd fd, -1 for file-backed/anonymous */
SyncReaderSlot *reader_slots; /* in mmap, SYNC_READER_SLOTS entries; NULL if not RWLock */
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 */
} SyncHandle;
/* ================================================================
* Utility
* ================================================================ */
static inline void sync_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
}
static inline int sync_pid_alive(uint32_t pid) {
if (pid == 0) return 1;
return !(kill((pid_t)pid, 0) == -1 && errno == ESRCH);
}
/* Convert timeout in seconds (double) to absolute deadline */
static inline void sync_make_deadline(double timeout, struct timespec *deadline) {
clock_gettime(CLOCK_MONOTONIC, deadline);
deadline->tv_sec += (time_t)timeout;
deadline->tv_nsec += (long)((timeout - (double)(time_t)timeout) * 1e9);
if (deadline->tv_nsec >= 1000000000L) {
deadline->tv_sec++;
deadline->tv_nsec -= 1000000000L;
}
}
/* Compute remaining timespec from absolute deadline. Returns 0 if deadline passed. */
static inline int sync_remaining_time(const struct timespec *deadline,
struct timespec *remaining) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
remaining->tv_sec = deadline->tv_sec - now.tv_sec;
remaining->tv_nsec = deadline->tv_nsec - now.tv_nsec;
if (remaining->tv_nsec < 0) {
remaining->tv_sec--;
remaining->tv_nsec += 1000000000L;
}
return remaining->tv_sec >= 0;
}
/* ================================================================
* Mutex helpers (for Condvar's internal mutex)
* ================================================================ */
#define SYNC_MUTEX_WRITER_BIT 0x80000000U
#define SYNC_MUTEX_PID_MASK 0x7FFFFFFFU
#define SYNC_MUTEX_VAL(pid) (SYNC_MUTEX_WRITER_BIT | ((uint32_t)(pid) & SYNC_MUTEX_PID_MASK))
static const struct timespec sync_lock_timeout = { SYNC_LOCK_TIMEOUT_SEC, 0 };
static inline void sync_recover_stale_mutex(SyncHeader *hdr, uint32_t observed) {
if (!__atomic_compare_exchange_n(&hdr->mutex, &observed, 0,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED))
return;
__atomic_add_fetch(&hdr->stat_recoveries, 1, __ATOMIC_RELAXED);
if (__atomic_load_n(&hdr->mutex_waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->mutex, FUTEX_WAKE, 1, NULL, NULL, 0);
}
static inline void sync_mutex_lock(SyncHeader *hdr) {
uint32_t mypid = SYNC_MUTEX_VAL((uint32_t)getpid());
for (int spin = 0; ; spin++) {
uint32_t expected = 0;
if (__atomic_compare_exchange_n(&hdr->mutex, &expected, mypid,
1, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
return;
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
sync_spin_pause();
continue;
}
__atomic_add_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
uint32_t cur = __atomic_load_n(&hdr->mutex, __ATOMIC_RELAXED);
if (cur != 0) {
long rc = syscall(SYS_futex, &hdr->mutex, FUTEX_WAIT, cur,
&sync_lock_timeout, NULL, 0);
if (rc == -1 && errno == ETIMEDOUT) {
__atomic_sub_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
uint32_t val = __atomic_load_n(&hdr->mutex, __ATOMIC_RELAXED);
if (val >= SYNC_MUTEX_WRITER_BIT) {
uint32_t pid = val & SYNC_MUTEX_PID_MASK;
if (!sync_pid_alive(pid))
sync_recover_stale_mutex(hdr, val);
}
spin = 0;
continue;
}
}
__atomic_sub_fetch(&hdr->mutex_waiters, 1, __ATOMIC_RELAXED);
spin = 0;
}
}
static inline void sync_mutex_unlock(SyncHeader *hdr) {
__atomic_store_n(&hdr->mutex, 0, __ATOMIC_RELEASE);
if (__atomic_load_n(&hdr->mutex_waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->mutex, FUTEX_WAKE, 1, NULL, NULL, 0);
}
/* ================================================================
* RWLock helpers (for SYNC_TYPE_RWLOCK)
*
* value == 0: unlocked
* value 1..0x7FFFFFFF: N active readers
* value 0x80000000 | pid: write-locked by pid
* ================================================================ */
#define SYNC_RWLOCK_WRITER_BIT 0x80000000U
#define SYNC_RWLOCK_PID_MASK 0x7FFFFFFFU
#define SYNC_RWLOCK_WR(pid) (SYNC_RWLOCK_WRITER_BIT | ((uint32_t)(pid) & SYNC_RWLOCK_PID_MASK))
static inline int sync_rwlock_try_rdlock(SyncHandle *h);
static inline int sync_rwlock_try_wrlock(SyncHandle *h);
static inline void sync_recover_stale_rwlock(SyncHeader *hdr, uint32_t observed) {
if (!__atomic_compare_exchange_n(&hdr->value, &observed, 0,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED))
return;
__atomic_add_fetch(&hdr->stat_recoveries, 1, __ATOMIC_RELAXED);
if (__atomic_load_n(&hdr->waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->value, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
/* ---- Per-process reader-slot lifecycle (dead-reader recovery) ----
* Each process claims one SyncReaderSlot lazily on first rwlock op so that
* its contribution to the shared reader-count can be reclaimed by other
* processes if it dies (SIGKILL'd reader no longer pins the counter).
* Only relevant for SYNC_TYPE_RWLOCK; non-RWLock primitives leave
* h->reader_slots == NULL and these helpers become no-ops. */
static uint32_t sync_fork_gen = 0;
static pthread_once_t sync_atfork_once = PTHREAD_ONCE_INIT;
static void sync_on_fork_child(void) {
__atomic_add_fetch(&sync_fork_gen, 1, __ATOMIC_RELAXED);
}
static void sync_atfork_init(void) {
pthread_atfork(NULL, NULL, sync_on_fork_child);
}
static inline void sync_claim_reader_slot(SyncHandle *h) {
if (!h->reader_slots) return;
pthread_once(&sync_atfork_once, sync_atfork_init);
uint32_t cur_gen = __atomic_load_n(&sync_fork_gen, __ATOMIC_RELAXED);
&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);
__atomic_store_n(&h->reader_slots[s].writers_parked, 0, __ATOMIC_RELAXED);
h->my_slot_idx = s;
return;
}
}
/* Slot table full — silently skip tracking; recovery falls back to
* the slow per-op timeout drain. */
}
/* Atomically subtract `sub` from a counter, capped at 0 (never underflows). */
static inline void sync_atomic_sub_cap(uint32_t *p, uint32_t sub) {
if (!sub) return;
uint32_t cur = __atomic_load_n(p, __ATOMIC_RELAXED);
for (;;) {
uint32_t want = (cur > sub) ? cur - sub : 0;
if (__atomic_compare_exchange_n(p, &cur, want,
1, __ATOMIC_RELAXED, __ATOMIC_RELAXED))
return;
}
}
/* Try to claim a dead slot (CAS pid → 0) and drain its parked-waiter
* contributions to the global counters. Returns 1 if drained, 0 if lost
* the CAS race or had no contributions. ACQ_REL syncs us with the dead
* process's RELAXED stores to mirror fields on weakly-ordered archs. */
static inline int sync_drain_dead_slot(SyncHandle *h, uint32_t i, uint32_t pid) {
SyncHeader *hdr = h->hdr;
uint32_t expected = pid;
if (!__atomic_compare_exchange_n(&h->reader_slots[i].pid, &expected, 0,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED))
return 0;
uint32_t wp = __atomic_load_n(&h->reader_slots[i].waiters_parked, __ATOMIC_RELAXED);
uint32_t writp = __atomic_load_n(&h->reader_slots[i].writers_parked, __ATOMIC_RELAXED);
int drained = 0;
if (wp) { sync_atomic_sub_cap(&hdr->waiters, wp); drained = 1; }
if (writp) { sync_atomic_sub_cap(&hdr->rwlock_writers_waiting, writp); drained = 1; }
/* Don't zero slot fields — sync_claim_reader_slot zeros them on the
* next claim; zeroing here can race a new claimant's increments. */
return drained;
}
static inline void sync_recover_dead_readers(SyncHandle *h) {
if (!h->reader_slots) return;
SyncHeader *hdr = h->hdr;
int any_live_reader = 0;
int found_dead_reader = 0;
int any_recovery = 0;
/* Pass 1: scan; classify; immediate-wipe dead slots with sc==0 (no
* rwlock contribution to lose). Defer wiping dead-with-sc>0 slots
* until force-reset can fire — otherwise we'd lose the only record
* of the orphan rwlock contribution while a live reader is present. */
for (uint32_t i = 0; i < SYNC_READER_SLOTS; i++) {
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue;
uint32_t sc = __atomic_load_n(&h->reader_slots[i].subcount, __ATOMIC_RELAXED);
if (sync_pid_alive(pid)) {
if (sc > 0) any_live_reader = 1;
continue;
}
if (sc > 0) { found_dead_reader = 1; continue; }
if (sync_drain_dead_slot(h, i, pid)) any_recovery = 1;
}
/* Pass 2: only if force-reset will fire. Issue the rwlock CAS first
* to keep the race window with new readers narrow, then wipe the
* deferred dead slots. */
if (found_dead_reader && !any_live_reader) {
uint32_t cur = __atomic_load_n(&hdr->value, __ATOMIC_RELAXED);
if (cur > 0 && cur < SYNC_RWLOCK_WRITER_BIT) {
if (__atomic_compare_exchange_n(&hdr->value, &cur, 0,
0, __ATOMIC_RELEASE, __ATOMIC_RELAXED)) {
any_recovery = 1;
if (__atomic_load_n(&hdr->waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->value, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
}
for (uint32_t i = 0; i < SYNC_READER_SLOTS; i++) {
uint32_t pid = __atomic_load_n(&h->reader_slots[i].pid, __ATOMIC_ACQUIRE);
if (pid == 0) continue;
if (sync_pid_alive(pid)) continue;
if (sync_drain_dead_slot(h, i, pid)) any_recovery = 1;
}
}
if (any_recovery)
__atomic_add_fetch(&hdr->stat_recoveries, 1, __ATOMIC_RELAXED);
}
/* Park/unpark helpers — keep global hdr->waiters/rwlock_writers_waiting
* and per-slot mirror counters in sync so recovery can drain them. */
static inline void sync_park_reader(SyncHandle *h) {
__atomic_add_fetch(&h->hdr->waiters, 1, __ATOMIC_RELAXED);
if (h->my_slot_idx != UINT32_MAX)
__atomic_add_fetch(&h->reader_slots[h->my_slot_idx].waiters_parked, 1, __ATOMIC_RELAXED);
}
static inline void sync_unpark_reader(SyncHandle *h) {
__atomic_sub_fetch(&h->hdr->waiters, 1, __ATOMIC_RELAXED);
if (h->my_slot_idx != UINT32_MAX)
__atomic_sub_fetch(&h->reader_slots[h->my_slot_idx].waiters_parked, 1, __ATOMIC_RELAXED);
}
static inline void sync_park_writer(SyncHandle *h) {
__atomic_add_fetch(&h->hdr->waiters, 1, __ATOMIC_RELAXED);
__atomic_add_fetch(&h->hdr->rwlock_writers_waiting, 1, __ATOMIC_RELAXED);
if (h->my_slot_idx != UINT32_MAX) {
__atomic_add_fetch(&h->reader_slots[h->my_slot_idx].waiters_parked, 1, __ATOMIC_RELAXED);
__atomic_add_fetch(&h->reader_slots[h->my_slot_idx].writers_parked, 1, __ATOMIC_RELAXED);
}
}
static inline void sync_unpark_writer(SyncHandle *h) {
__atomic_sub_fetch(&h->hdr->waiters, 1, __ATOMIC_RELAXED);
__atomic_sub_fetch(&h->hdr->rwlock_writers_waiting, 1, __ATOMIC_RELAXED);
if (h->my_slot_idx != UINT32_MAX) {
__atomic_sub_fetch(&h->reader_slots[h->my_slot_idx].waiters_parked, 1, __ATOMIC_RELAXED);
__atomic_sub_fetch(&h->reader_slots[h->my_slot_idx].writers_parked, 1, __ATOMIC_RELAXED);
}
}
/* Recovery dispatcher: if a writer is dead, force-reset the lock word;
* otherwise scan reader slots for dead readers and drain their stuck
* contributions to the rwlock and waiter counters. Reload the lock
* value here (rather than trusting a stale snapshot from the futex
* caller) so that (a) a writer that died after our futex_wait started
* is detected on the same timeout, and (b) phantom waiter/writers_waiting
* contributions left by a dead parked writer are drained even when the
* lock word itself is now 0. */
static inline void sync_recover_after_timeout(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
uint32_t val = __atomic_load_n(&hdr->value, __ATOMIC_RELAXED);
if (val >= SYNC_RWLOCK_WRITER_BIT) {
uint32_t pid = val & SYNC_RWLOCK_PID_MASK;
if (!sync_pid_alive(pid))
sync_recover_stale_rwlock(hdr, val);
} else {
sync_recover_dead_readers(h);
}
}
static inline void sync_rwlock_rdlock(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
sync_claim_reader_slot(h);
uint32_t *lock = &hdr->value;
uint32_t *writers_waiting = &hdr->rwlock_writers_waiting;
/* Bump per-process subcount BEFORE attempting the rwlock CAS so a
* concurrent recovery scan sees us as a live in-flight reader. */
if (h->my_slot_idx != UINT32_MAX)
__atomic_add_fetch(&h->reader_slots[h->my_slot_idx].subcount, 1, __ATOMIC_RELAXED);
for (int spin = 0; ; spin++) {
uint32_t cur = __atomic_load_n(lock, __ATOMIC_RELAXED);
/* Write-preferring: yield to parked writers when lock is free. */
if (cur > 0 && cur < SYNC_RWLOCK_WRITER_BIT) {
if (__atomic_compare_exchange_n(lock, &cur, cur + 1,
1, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
return;
} else if (cur == 0 && !__atomic_load_n(writers_waiting, __ATOMIC_RELAXED)) {
if (__atomic_compare_exchange_n(lock, &cur, 1,
1, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
return;
}
if (__builtin_expect(spin < SYNC_SPIN_LIMIT, 1)) {
sync_spin_pause();
continue;
}
sync_park_reader(h);
cur = __atomic_load_n(lock, __ATOMIC_RELAXED);
/* Sleep when write-locked OR yielding to parked writers (cur==0) */
if (cur >= SYNC_RWLOCK_WRITER_BIT || cur == 0) {
long rc = syscall(SYS_futex, lock, FUTEX_WAIT, cur,
&sync_lock_timeout, NULL, 0);
if (rc == -1 && errno == ETIMEDOUT) {
sync_unpark_reader(h);
if (cur >= SYNC_RWLOCK_WRITER_BIT) {
sync_recover_after_timeout(h);
} else {
/* Yielding to writers timed out — optimistically drop one
* writers_waiting to recover from potentially-crashed
* parked writer. A live writer just re-increments. */
uint32_t wc = __atomic_load_n(writers_waiting, __ATOMIC_RELAXED);
while (wc > 0 && !__atomic_compare_exchange_n(
writers_waiting, &wc, wc - 1,
1, __ATOMIC_RELAXED, __ATOMIC_RELAXED)) {}
/* Also opportunistically reap dead-reader slot mirrors
* (some other reader holds the lock but may be dead). */
sync_recover_dead_readers(h);
}
spin = 0;
continue;
}
}
sync_unpark_reader(h);
spin = 0;
}
*
* value states: 0=INIT, (SYNC_MUTEX_WRITER_BIT|pid)=RUNNING, 1=DONE
* ================================================================ */
#define SYNC_ONCE_INIT 0
#define SYNC_ONCE_DONE 1
/* RUNNING = SYNC_MUTEX_WRITER_BIT | pid */
static inline int sync_once_is_done(SyncHandle *h) {
return __atomic_load_n(&h->hdr->value, __ATOMIC_ACQUIRE) == SYNC_ONCE_DONE;
}
/* Try to become the initializer. Returns:
* 1 = you are the initializer, call once_done() when finished
* 0 = already done
* -1 = another process is initializing (wait with once_wait) */
static inline int sync_once_try(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
uint32_t mypid = SYNC_MUTEX_VAL((uint32_t)getpid());
uint32_t expected = SYNC_ONCE_INIT;
if (__atomic_compare_exchange_n(&hdr->value, &expected, mypid,
0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
__atomic_add_fetch(&hdr->stat_acquires, 1, __ATOMIC_RELAXED);
return 1;
}
if (expected == SYNC_ONCE_DONE) return 0;
return -1;
}
/* Call/wait combo: try to become initializer, or wait for completion.
* Returns 1 if caller is the initializer, 0 if already done or waited. */
static inline int sync_once_enter(SyncHandle *h, double timeout) {
SyncHeader *hdr = h->hdr;
/* Non-blocking probe: just try, don't wait */
int r = sync_once_try(h);
if (r == 1) return 1;
if (r == 0) return 0;
if (timeout == 0) return 0;
struct timespec deadline, remaining;
int has_deadline = (timeout > 0);
if (has_deadline) sync_make_deadline(timeout, &deadline);
__atomic_add_fetch(&hdr->stat_waits, 1, __ATOMIC_RELAXED);
for (;;) {
r = sync_once_try(h);
if (r == 1) return 1; /* caller is initializer */
if (r == 0) return 0; /* already done */
/* r == -1: someone else is running. Wait or detect stale. */
uint32_t val = __atomic_load_n(&hdr->value, __ATOMIC_ACQUIRE);
if (val == SYNC_ONCE_DONE) return 0;
if (val == SYNC_ONCE_INIT) continue; /* race: was reset, retry */
/* Check stale initializer */
if (val >= SYNC_MUTEX_WRITER_BIT) {
uint32_t pid = val & SYNC_MUTEX_PID_MASK;
if (!sync_pid_alive(pid)) {
if (__atomic_compare_exchange_n(&hdr->value, &val, SYNC_ONCE_INIT,
0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)) {
__atomic_add_fetch(&hdr->stat_recoveries, 1, __ATOMIC_RELAXED);
if (__atomic_load_n(&hdr->waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->value, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
continue;
}
}
__atomic_add_fetch(&hdr->waiters, 1, __ATOMIC_RELAXED);
/* Always cap at SYNC_LOCK_TIMEOUT_SEC so stale-initializer recovery
* runs periodically even when the caller specifies infinite timeout. */
struct timespec *pts = (struct timespec *)&sync_lock_timeout;
if (has_deadline) {
if (!sync_remaining_time(&deadline, &remaining)) {
__atomic_sub_fetch(&hdr->waiters, 1, __ATOMIC_RELAXED);
__atomic_add_fetch(&hdr->stat_timeouts, 1, __ATOMIC_RELAXED);
return 0;
}
if (remaining.tv_sec < SYNC_LOCK_TIMEOUT_SEC)
pts = &remaining;
}
syscall(SYS_futex, &hdr->value, FUTEX_WAIT, val, pts, NULL, 0);
__atomic_sub_fetch(&hdr->waiters, 1, __ATOMIC_RELAXED);
}
}
static inline void sync_once_done(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
__atomic_store_n(&hdr->value, SYNC_ONCE_DONE, __ATOMIC_RELEASE);
__atomic_add_fetch(&hdr->stat_releases, 1, __ATOMIC_RELAXED);
if (__atomic_load_n(&hdr->waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->value, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
static inline void sync_once_reset(SyncHandle *h) {
SyncHeader *hdr = h->hdr;
__atomic_store_n(&hdr->value, SYNC_ONCE_INIT, __ATOMIC_RELEASE);
if (__atomic_load_n(&hdr->waiters, __ATOMIC_RELAXED) > 0)
syscall(SYS_futex, &hdr->value, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
/* ================================================================
* Create / Open / Close
*
* Layout:
* [0..127] : SyncHeader
* [128..128+SLOTS_SIZE-1] : SyncReaderSlot[SYNC_READER_SLOTS] (RWLock only)
*
* Non-RWLock primitives keep total_size = sizeof(SyncHeader) (Option A:
* pay-for-what-you-use, ~16KB only when needed).
* ================================================================ */
#define SYNC_ERR(fmt, ...) do { if (errbuf) snprintf(errbuf, SYNC_ERR_BUFLEN, fmt, ##__VA_ARGS__); } while(0)
static inline uint64_t sync_layout_total_size(uint32_t type) {
uint64_t sz = sizeof(SyncHeader);
( run in 1.464 second using v1.01-cache-2.11-cpan-df04353d9ac )