Package ck-devel

Header files and libraries for CK development

http://concurrencykit.org

Concurrency Kit provides a plethora of concurrency primitives, safe memory
reclamation mechanisms and lock-less and lock-free data structures designed to
aid in the design and implementation of high performance concurrent systems. It
is designed to minimize dependencies on operating system-specific interfaces
and most of the interface relies only on a strict subset of the standard
library and more popular compiler extensions.

This package provides the libraries, include files, and other
resources needed for developing Concurrency Kit applications.

Library Functions
Library Function Description
ck_array_buffer return length and pointer to array of reader-visible pointers
ck_array_commit linearization point for mutations before commit call
ck_array_deinit destroy and deinitialize a pointer array
CK_ARRAY_FOREACH iterate through an array
ck_array_init initialize a pointer array
ck_array_initialized indicates whether an array was recently initialized or deinitialized
ck_array_length returns the number of pointers committed to an array
ck_array_put attempt immediate or deferred insertion of a pointer into array
ck_array_put_unique attempt immediate or deferred insertion of a unique pointer into array
ck_array_remove attempt immediate or deferred removal of a pointer from an array
ck_bitmap_base determine the size of a bit array in bytes
ck_bitmap_bits return number of addressable bits in bitmap
ck_bitmap_bts set the bit at the specified index and fetch its original value
ck_bitmap_buffer returns pointer to bit array
ck_bitmap_clear reset all bits
ck_bitmap_init initialize a bitmap
ck_bitmap_iterator_init initialize bitmap iterator
ck_bitmap_next iterate to the next set bit in bitmap
ck_bitmap_reset resets the bit at the specified index
ck_bitmap_set set the bit at the specified index
ck_bitmap_size returns necessary number of bytes for bitmap
ck_bitmap_test determine if the bit at the specified index is set
ck_bitmap_union generates union of two bitmaps
ck_brlock big-reader locks
ck_cohort generalized interface for lock cohorts
CK_COHORT_INIT initialize instance of a cohort type
CK_COHORT_INSTANCE declare an instance of a cohort type
CK_COHORT_LOCK acquire cohort lock
CK_COHORT_PROTOTYPE define cohort type with specified lock types
CK_COHORT_TRYLOCK try to acquire cohort lock
CK_COHORT_TRYLOCK_PROTOTYPE define cohort type with specified lock types
CK_COHORT_UNLOCK release cohort lock
ck_elide lock elision wrappers
ck_epoch_barrier block until a grace period and all callbacks have been dispatched
ck_epoch_begin begin epoch-protected segment of execution
ck_epoch_call defer function execution until a grace period
ck_epoch_end end epoch-protected segment of execution
ck_epoch_init initialize epoch reclamation object
ck_epoch_poll non-blocking poll of epoch object for dispatch cycles
ck_epoch_reclaim immediately execute all deferred callbacks
ck_epoch_recycle return an epoch record that may be used by caller
ck_epoch_register register a thread for epoch reclamation
ck_epoch_synchronize block until a grace period has been detected
ck_epoch_unregister unregister a thread for epoch reclamation
ck_hs_apply apply a function to hash set value
ck_hs_count returns number of entries in hash set
ck_hs_destroy destroy hash set
ck_hs_fas fetch and store key in hash set
ck_hs_gc perform maintenance on a hash set
ck_hs_get load a key from a hash set
ck_hs_grow enlarge hash set capacity
CK_HS_HASH invoke hash function with hash set seed
ck_hs_init initialize a hash set
ck_hs_iterator_init initialize hash set iterator
ck_hs_move move one from hash set to another
ck_hs_next iterate to next entry in hash set
ck_hs_put store unique key into a hash set
ck_hs_put_unique unconditionally store unique key into a hash set
ck_hs_rebuild rebuild a hash set
ck_hs_remove remove key from a hash set
ck_hs_reset remove all keys from a hash set
ck_hs_reset_size remove all keys from a hash set
ck_hs_set store key into a hash set
ck_hs_stat get hash set status
ck_ht_count return count of key-value pairs in hash table
ck_ht_destroy immediately destroy a hash table
ck_ht_entry_empty determine whether entry contains a key-value pair
ck_ht_entry_key return pointer to key as specified in hash table entry
ck_ht_entry_key_direct return key value as specified in hash table entry
ck_ht_entry_key_length returns the length of the key specified in the argument
ck_ht_entry_key_set initialize pointer to key in hash table entry
ck_ht_entry_key_set_direct initialize key value in hash table entry
ck_ht_entry_set initialize a key-value pair
ck_ht_entry_set_direct initialize a key-value pair
ck_ht_entry_value return pointer to value as specified in hash table entry
ck_ht_entry_value_direct return value as specified in hash table entry
ck_ht_gc perform maintenance on a hash table
ck_ht_get_spmc load a key-value pair from a hash table
ck_ht_grow_spmc resize a hash table if necessary
ck_ht_hash generate a hash value for a hash table
ck_ht_hash_direct generate a hash value for a hash table
ck_ht_init initialize a hash table
ck_ht_iterator_init initialize hash table iterator
ck_ht_next iterate to next entry in hash table
ck_ht_put_spmc store unique key-value pair into hash table
ck_ht_remove_spmc resize a hash table if necessary
ck_ht_reset_size_spmc remove all entries from a hash table and reset size
ck_ht_reset_spmc remove all entries from a hash table
ck_ht_set_spmc store key-value pair into hash table
ck_ht_stat get hash table status
ck_pflock centralized phase-fair reader-writer locks
ck_pr concurrency primitives interface
ck_pr_add atomic addition operations
ck_pr_and atomic bitwise-and operations
ck_pr_barrier compiler optimization barrier
ck_pr_btc atomic bit test-and-complement operations
ck_pr_btr atomic bit test-and-reset operations
ck_pr_bts atomic bit test-and-set operations
ck_pr_cas atomic compare-and-swap operations
ck_pr_dec atomic decrement operations
ck_pr_faa atomic fetch-and-add operations
ck_pr_fas atomic swap operations
ck_pr_fence_acquire enforce acquire semantics
ck_pr_fence_atomic enforce partial ordering of atomic read-modify-write operations
ck_pr_fence_atomic_load enforce ordering of atomic read-modify-write operations to load operations
ck_pr_fence_atomic_store enforce ordering of atomic read-modify-write operations to store operations
ck_pr_fence_load enforce partial ordering of load operations
ck_pr_fence_load_atomic enforce ordering of load operations to atomic read-modify-write operations
ck_pr_fence_load_depends data dependency barrier
ck_pr_fence_load_store enforce ordering of load operations to store operations
ck_pr_fence_memory enforce partial ordering of all memory operations
ck_pr_fence_release enforce release semantics
ck_pr_fence_store enforce partial ordering of store operations
ck_pr_fence_store_atomic enforce ordering of store operations to load operations
ck_pr_fence_store_load enforce ordering of store operations to load operations
ck_pr_inc atomic increment operations
ck_pr_load atomic volatile load operations
ck_pr_neg atomic negation operations
ck_pr_not atomic complement operations
ck_pr_or atomic bitwise-or operations
ck_pr_rtm restricted transactional memory
ck_pr_stall busy-wait primitive
ck_pr_store atomic volatile store operations
ck_pr_sub atomic subtraction operations
ck_pr_xor atomic bitwise-xor operations
ck_queue multi-reader single-writer singly-linked lists, singly-linked tail queues and...
ck_rhs_apply apply a function to hash set value
ck_rhs_count returns number of entries in hash set
ck_rhs_destroy destroy hash set
ck_rhs_fas fetch and store key in hash set
ck_rhs_gc perform maintenance on a hash set
ck_rhs_get load a key from a hash set
ck_rhs_grow enlarge hash set capacity
CK_RHS_HASH invoke hash function with hash set seed
ck_rhs_init initialize a hash set
ck_rhs_iterator_init initialize hash set iterator
ck_rhs_move move one from hash set to another
ck_rhs_next iterate to next entry in hash set
ck_rhs_put store unique key into a hash set
ck_rhs_put_unique unconditionally store unique key into a hash set
ck_rhs_rebuild rebuild a hash set
ck_rhs_remove remove key from a hash set
ck_rhs_reset remove all keys from a hash set
ck_rhs_reset_size remove all keys from a hash set
ck_rhs_set store key into a hash set
ck_rhs_stat get hash set status
ck_ring_capacity returns number of pointer slots in bounded FIFO
ck_ring_dequeue_spmc dequeue pointer from bounded FIFO
ck_ring_dequeue_spsc dequeue pointer from bounded FIFO
ck_ring_enqueue_spmc enqueue pointer into bounded FIFO
ck_ring_enqueue_spmc_size enqueue pointer into bounded FIFO and return size of buffer
ck_ring_enqueue_spsc enqueue pointer into bounded FIFO
ck_ring_enqueue_spsc_size enqueue pointer into bounded FIFO and return size of buffer
ck_ring_init initialize bounded FIFO
ck_ring_size return number of pointers enqueued in bounded FIFO
ck_ring_trydequeue_spmc dequeue from bounded FIFO and allow for spurious failure
ck_rwcohort generalized interface for reader-writer locks using cohort locks
CK_RWCOHORT_INIT initialize instance of a cohort-based reader-writer lock type
CK_RWCOHORT_INSTANCE declare an instance of a cohort-based reader-writer lock type
CK_RWCOHORT_PROTOTYPE define reader-writer cohort-based lock using the specified cohort type
CK_RWCOHORT_READ_LOCK acquire read-only permission for cohort-based reader-writer lock
CK_RWCOHORT_READ_UNLOCK relinquish read-only access to cohort-based reader-writer lock
CK_RWCOHORT_WRITE_LOCK acquite write access for a cohort-based reader-writer lock
CK_RWCOHORT_WRITE_UNLOCK relinquish write access for cohort-based reader-writer lock
ck_rwlock centralized write-biased reader-writer locks
ck_sequence sequence locks
ck_spinlock spinlock implementations
ck_swlock centralized copy-safe write-biased single-writer read-write locks
ck_tflock centralized task-fair reader-writer locks