Package ck-devel
Header files and libraries for CK development
https://github.com/concurrencykit/ck
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.
Version: 0.7.1
Library Functions | |
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-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_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-linked lists, singly-linked tail queues and lists |
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-writer read-write locks |
ck_tflock | centralized task-fair reader-writer locks |