sync #

fn channel_select(mut channels []&Channel, dir []Direction, mut objrefs []voidptr, timeout time.Duration) int

Wait timeout on any of channels[i] until one of them can push (is_push[i] = true) or pop (is_push[i] = false) object referenced by objrefs[i]. timeout < 0 means wait unlimited time. timeout == 0 means return immediately if no transaction can be performed without waiting. return value: the index of the channel on which a transaction has taken place -1 if waiting for a transaction has exceeded timeout -2 if all channels are closed

fn new_channel<T>(n u32) &Channel

fn new_mutex() &Mutex

fn new_pool_processor(context PoolProcessorConfig) &PoolProcessor

new_pool_processor returns a new PoolProcessor instance.

fn new_rwmutex() &RwMutex

fn new_semaphore() Semaphore

fn new_semaphore_init(n u32) Semaphore

fn new_waiter() &Waiter

fn new_waitgroup() &WaitGroup

fn (mut ch Channel) close()

fn (mut ch Channel) len() int

fn (mut ch Channel) push(src voidptr)

fn (mut ch Channel) try_push(src voidptr) ChanState

fn (mut ch Channel) pop(dest voidptr) bool

fn (mut ch Channel) try_pop(dest voidptr) ChanState

type ThreadCB = fn (p &PoolProcessor, idx int, task_id int) voidptr

fn (mut w Waiter) wait()

fn (mut w Waiter) stop()

fn (mut wg WaitGroup) add(delta int)

add increments (+ve delta) or decrements (-ve delta) task count by delta and unblocks any wait() calls if task count becomes zero. add panics if task count drops below zero.

fn (mut wg WaitGroup) done()

done is a convenience fn for add(-1)

fn (mut wg WaitGroup) wait()

wait blocks until all tasks are done (task count becomes zero)

struct IResult {
pub:
	i int
}

struct Mutex {
	mutex C.pthread_mutex_t
}

[init_with=new_mutex] // TODO: implement support for this struct attribute, and disallow Mutex{} from outside the sync.new_mutex() function.

fn (mut m Mutex) m_lock()

m_lock(), for manual mutex handling, since lock is a keyword

fn (mut m Mutex) unlock()

struct PoolProcessor {
	thread_cb voidptr
mut:
	njobs           int
	items           []voidptr
	results         []voidptr
	ntask           int
	ntask_mtx       &Mutex
	waitgroup       &WaitGroup
	shared_context  voidptr
	thread_contexts []voidptr
}

fn (mut pool PoolProcessor) set_max_jobs(njobs int)

set_max_jobs gives you the ability to override the number of jobs after the PoolProcessor had been created already.

fn (mut pool PoolProcessor) work_on_pointers(items []voidptr)

work_on_items receives a list of items of type T, then starts a work pool of pool.njobs threads, each running pool.thread_cb in a loop, untill all items in the list, are processed. When pool.njobs is 0, the number of jobs is determined by the number of available cores on the system. work_on_items returns after all threads finish. You can optionally call get_results after that. TODO: uncomment, when generics work again pub fn (mut pool PoolProcessor) work_on_items<T>(items []T) { pool.work_on_pointers( items.pointers() ) }

fn (pool &PoolProcessor) get_string_item(idx int) string

get_item - called by the worker callback. Retrieves a type safe instance of the currently processed item TODO: uncomment, when generics work again pub fn (pool &PoolProcessor) get_item<T>(idx int) T { return *(&T(pool.items[idx])) } get_string_item - called by the worker callback. It does not use generics so it does not mess up vfmt. TODO: remove the need for this when vfmt becomes smarter.

fn (pool &PoolProcessor) get_int_item(idx int) int

get_int_item - called by the worker callback. It does not use generics so it does not mess up vfmt. TODO: remove the need for this when vfmt becomes smarter.

fn (mut pool PoolProcessor) set_shared_context(context voidptr)

TODO: uncomment, when generics work again pub fn (pool &PoolProcessor) get_result<T>(idx int) T { return *(&T(pool.results[idx])) } TODO: uncomment, when generics work again get_results - can be called to get a list of type safe results. pub fn (pool &PoolProcessor) get_results<T>() []T { mut res := []T{} for i in 0 .. pool.results.len { res << *(&T(pool.results[i])) } return res } set_shared_context - can be called during the setup so that you can provide a context that is shared between all worker threads, like common options/settings.

fn (pool &PoolProcessor) get_shared_context() voidptr

get_shared_context - can be called in each worker callback, to get the context set by pool.set_shared_context

fn (mut pool PoolProcessor) set_thread_context(idx int, context voidptr)

set_thread_context - can be called during the setup at the start of each worker callback, so that the worker callback can have some thread local storage area where it can write/read information that is private to the given thread, without worrying that it will get overwritten by another thread

fn (pool &PoolProcessor) get_thread_context(idx int) voidptr

get_thread_context - returns a pointer, that was set with pool.set_thread_context . This pointer is private to each thread.

fn (mut pool PoolProcessor) work_on_items_s(items []string)

fn (mut pool PoolProcessor) work_on_items_i(items []int)

fn (pool &PoolProcessor) get_results_s() []SResult

fn (pool &PoolProcessor) get_results_i() []IResult

struct PoolProcessorConfig {
	maxjobs  int
	callback ThreadCB
}

struct RwMutex {
	mutex C.pthread_rwlock_t
}

fn (mut m RwMutex) r_lock()

RwMutex has separate read- and write locks

fn (mut m RwMutex) w_lock()

fn (mut m RwMutex) r_unlock()

Windows SRWLocks have different function to unlock So provide two functions here, too, to have a common interface

fn (mut m RwMutex) w_unlock()

struct Semaphore {
mut:
	sem voidptr
}

fn (s Semaphore) post()

fn (s Semaphore) wait()

fn (s Semaphore) try_wait() bool

fn (s Semaphore) timed_wait(timeout time.Duration) bool

fn (s Semaphore) destroy() bool

struct SResult {
pub:
	s string
}

TODO: remove everything below this line after generics are fixed: