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/

                                                September 2, 2012                               CK_EPOCH_CALL(3)