Package ck-devel

Header files and libraries for CK development

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

Library Functions