CK_EPOCH_CALL(3)

NAME
ck_epoch_call - defer function execution until a grace period

LIBRARY
Concurrency Kit (libck, -lck)

SYNOPSIS
#include <ck_epoch.h>
typedef struct ck_epoch_entry ck_epoch_entry_t;
typedef void ck_epoch_cb_t(ck_epoch_entry_t *);
void
ck_epoch_call(ck_epoch_record_t *record, ck_epoch_entry_t *entry, ck_epoch_cb_t *function);

DESCRIPTION
The ck_epoch_call(3) function will defer the execution of the function pointed to by function until a grace-period has been detected in epoch. The function will be provided the pointer specified by entry. The function will execute at some time in the future via calls to ck_epoch_reclaim(3), ck_epoch_barrier(3) or ck_epoch_poll(3).

EXAMPLE

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

    /*
     * epoch was previously initialized with ck_epoch_init.
     */
    ck_epoch_t *epoch;

    struct object {
    	int value;
    	ck_epoch_entry_t epoch_entry;
    };
    static struct object *global;

    CK_EPOCH_CONTAINER(struct object, epoch_entry, object_container)

    void
    destroy_object(ck_epoch_entry_t *e)
    {
    	struct object *o = object_container(e);

    	free(o);
    	return;
    }

    void
    function(void)
    {
    	ck_epoch_record_t *record;
    	struct object *n;

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

    	n = malloc(sizeof *n);
    	if (n == NULL)
    		return;

    	n->value = 1;

    	/*
    	 * We are using an epoch section here because there are multiple
    	 * writers. It is also an option to use other forms of blocking
    	 * write-side synchronization such as mutexes.
    	 */
    	ck_epoch_begin(record);
    	n = ck_pr_fas_ptr(&global, n);
    	ck_epoch_end(record);

    	/* Defer destruction of previous object. */
    	ck_epoch_call(record, &n->epoch_entry, destroy_object);

    	/* Poll epoch sub-system in non-blocking manner. */
    	ck_epoch_poll(record);
    	return;
    }

RETURN VALUES
This function has no return value.

ERRORS
The object pointed to by record must have been previously registered via ck_epoch_register(3).

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_barrier(3), ck_epoch_begin(3), ck_epoch_end(3)

Additional information available at http://concurrencykit.org/