#ifndef JEMALLOC_INTERNAL_SEQ_H
|
#define JEMALLOC_INTERNAL_SEQ_H
|
|
#include "jemalloc/internal/atomic.h"
|
|
/*
|
* A simple seqlock implementation.
|
*/
|
|
#define seq_define(type, short_type) \
|
typedef struct { \
|
atomic_zu_t seq; \
|
atomic_zu_t data[ \
|
(sizeof(type) + sizeof(size_t) - 1) / sizeof(size_t)]; \
|
} seq_##short_type##_t; \
|
\
|
/* \
|
* No internal synchronization -- the caller must ensure that there's \
|
* only a single writer at a time. \
|
*/ \
|
static inline void \
|
seq_store_##short_type(seq_##short_type##_t *dst, type *src) { \
|
size_t buf[sizeof(dst->data) / sizeof(size_t)]; \
|
buf[sizeof(buf) / sizeof(size_t) - 1] = 0; \
|
memcpy(buf, src, sizeof(type)); \
|
size_t old_seq = atomic_load_zu(&dst->seq, ATOMIC_RELAXED); \
|
atomic_store_zu(&dst->seq, old_seq + 1, ATOMIC_RELAXED); \
|
atomic_fence(ATOMIC_RELEASE); \
|
for (size_t i = 0; i < sizeof(buf) / sizeof(size_t); i++) { \
|
atomic_store_zu(&dst->data[i], buf[i], ATOMIC_RELAXED); \
|
} \
|
atomic_store_zu(&dst->seq, old_seq + 2, ATOMIC_RELEASE); \
|
} \
|
\
|
/* Returns whether or not the read was consistent. */ \
|
static inline bool \
|
seq_try_load_##short_type(type *dst, seq_##short_type##_t *src) { \
|
size_t buf[sizeof(src->data) / sizeof(size_t)]; \
|
size_t seq1 = atomic_load_zu(&src->seq, ATOMIC_ACQUIRE); \
|
if (seq1 % 2 != 0) { \
|
return false; \
|
} \
|
for (size_t i = 0; i < sizeof(buf) / sizeof(size_t); i++) { \
|
buf[i] = atomic_load_zu(&src->data[i], ATOMIC_RELAXED); \
|
} \
|
atomic_fence(ATOMIC_ACQUIRE); \
|
size_t seq2 = atomic_load_zu(&src->seq, ATOMIC_RELAXED); \
|
if (seq1 != seq2) { \
|
return false; \
|
} \
|
memcpy(dst, buf, sizeof(type)); \
|
return true; \
|
}
|
|
#endif /* JEMALLOC_INTERNAL_SEQ_H */
|
