Manual Pages


CK_ARRAY_FOREACH iterate through an array
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_HS_HASH invoke hash function with hash set seed
CK_RHS_HASH invoke hash function with hash set seed
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
CK_RWCOHORT_READ_UNLOCK relinquish read-only access to cohort-based reader
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_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_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_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_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
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_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_rwlock centralized write-biased reader-writer locks
ck_sequence sequence locks
ck_spinlock spinlock implementations
ck_swlock centralized copy-safe write-biased single
ck_tflock centralized task-fair reader-writer locks