DragonFly On-Line Manual Pages

CK_EPOCH_CALL(3)      DragonFly Library Functions Manual      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);

                   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