CK_EPOCH_BARRIER(3)

✨ ck_epoch_barrier(3) ✨

okay bestie, buckle up 💖 this is ck_epoch_barrier from the Concurrency Kit — that's libck, and you link it with -lck. it's giving "wait for the vibes to settle before you delete anything" and honestly? iconic. 🎀

🌸 SYNOPSIS 🌸

#include <ck_epoch.h>

void
ck_epoch_barrier(ck_epoch_record_t *record);

💅 DESCRIPTION 💅

so ck_epoch_barrier(3) is the "hold up, let's all calm down" function 🫶. it blocks the caller until a grace period has been detected, following the rules of epoch reclamation. what does that mean for you? it means any object that needs safe memory reclamation and has been logically deleted is now safe for physical deletion once you've called ck_epoch_barrier(3). no cap. 🔥

and that's not even all of it — this function will also dispatch all the callbacks associated with epoch that you'd previously scheduled with ck_epoch_call(3). two for one, we love an efficient queen. 👑

🦋 EXAMPLE 🦋

#include <ck_epoch.h>
#include <ck_stack.h>
#include <stdlib.h>

/*
 * epoch was previously initialized with ck_epoch_init.
 * stack was previously initialized with ck_stack_init.
 */
ck_epoch_t *epoch;
ck_stack_t *stack;

void
function(void)
{
        ck_epoch_record_t *record;
        ck_stack_entry_t *s;

        record = malloc(sizeof *record);
        ck_epoch_register(&epoch, record, NULL);

        /*
         * We are using an epoch section here to guarantee no
         * nodes in the stack are deleted while we are dereferencing
         * them. This is needed here because there are multiple writers.
         * If there was only one thread popping from the this stack,
         * then there is no need to ck_epoch_begin/ck_epoch_end.
         */
        ck_epoch_begin(record);

        /* Logically delete an object. */
        s = ck_stack_pop_upmc(stack);

        ck_epoch_end(record);

        /*
         * Wait until no threads could possibly have a reference to the
         * object we just popped (assume all threads are simply executing
         * ck_stack_pop_upmc).
         */
        ck_epoch_barrier(record);

        /* It is now safe to physically delete the object. */
        free(s);
        return;
}

⭐ RETURN VALUES ⭐

this one has no return value. she simply does the thing and leaves. periodt. 💅

🙈 ERRORS 🙈

behavior is undefined if the object pointed to by epoch is not a valid epoch object 😭 like, genuinely undefined, not in a cute way. also, the object pointed to by record must have been previously registered via ck_epoch_register(3). don't skip that step bestie, it's not optional. 🚨

🌈 SEE ALSO 🌈

• ck_epoch_init(3)
• ck_epoch_register(3)
• ck_epoch_unregister(3)
• ck_epoch_recycle(3)
• ck_epoch_poll(3)
• ck_epoch_synchronize(3)
• ck_epoch_reclaim(3)
• ck_epoch_call(3)
• ck_epoch_begin(3)
• ck_epoch_end(3)

more info lives at http://concurrencykit.org/ ✨ go read it, i'll wait 💜

and that's the whole page!! 🧚 this edition was dated September 2, 2012 and it's filed under CK_EPOCH_BARRIER(3) — slay, bye bestie! 🍓💖