starpu-max/doc/doxygen/chapters/api/workers.doxy

/*
 * This file is part of the StarPU Handbook.
 * Copyright (C) 2009--2011  Universit@'e de Bordeaux
 * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2016, 2017  CNRS
 * Copyright (C) 2011, 2012, 2017  INRIA
 * See the file version.doxy for copying conditions.
 */

/*! \defgroup API_Workers_Properties Workers’ Properties

\def STARPU_NMAXWORKERS
\ingroup API_Workers_Properties
Define the maximum number of workers managed by StarPU.

\def STARPU_MAXCPUS
\ingroup API_Workers_Properties
Define the maximum number of CPU workers managed by StarPU. The default value can be modified at
configure by using the option \ref enable-maxcpus "--enable-maxcpus".

\def STARPU_MAXNODES
\ingroup API_Workers_Properties
Define the maximum number of memory nodes managed by StarPU. The default value can be modified at
configure by using the option \ref enable-maxnodes "--enable-maxnodes". Reducing it allows to
considerably reduce memory used by StarPU data structures.

\enum starpu_node_kind
\ingroup API_Workers_Properties
    TODO
\var starpu_node_kind::STARPU_UNUSED
    TODO
\var starpu_node_kind::STARPU_CPU_RAM
    TODO
\var starpu_node_kind::STARPU_CUDA_RAM
    TODO
\var starpu_node_kind::STARPU_OPENCL_RAM
    TODO
\var starpu_node_kind::STARPU_DISK_RAM
    TODO
\var starpu_node_kind::STARPU_MIC_RAM
    TODO
\var starpu_node_kind::STARPU_SCC_RAM
    This node kind is not used anymore, but implementations in
    interfaces will be useful for MPI.
\var starpu_node_kind::STARPU_SCC_SHM
    TODO
\var starpu_node_kind::STARPU_MPI_MS_RAM
    TODO

\enum starpu_worker_archtype
\ingroup API_Workers_Properties
Worker Architecture Type
\var starpu_worker_archtype::STARPU_ANY_WORKER
    any worker, used in the hypervisor
\var starpu_worker_archtype::STARPU_CPU_WORKER
    CPU core
\var starpu_worker_archtype::STARPU_CUDA_WORKER
    NVIDIA CUDA device
\var starpu_worker_archtype::STARPU_OPENCL_WORKER
    OpenCL device
\var starpu_worker_archtype::STARPU_MIC_WORKER
    Intel MIC device
\var starpu_worker_archtype::STARPU_SCC_WORKER
    Intel SCC device
\var starpu_worker_archtype::STARPU_MPI_MS_WORKER
    MPI Slave device

\struct starpu_worker_collection
\ingroup API_Workers_Properties
A scheduling context manages a collection of workers that can
be memorized using different data structures. Thus, a generic
structure is available in order to simplify the choice of its type.
Only the list data structure is available but further data
structures(like tree) implementations are foreseen.
\var void *starpu_worker_collection::workerids
        The workerids managed by the collection
\var void *starpu_worker_collection::collection_private
        todo
\var void *starpu_worker_collection::unblocked_workers
        todo
\var unsigned starpu_worker_collection::nunblocked_workers
        todo
\var void *starpu_worker_collection::masters
        todo
\var unsigned starpu_worker_collection::nmasters
        todo
\var char starpu_worker_collection::present[STARPU_NMAXWORKERS]
        todo
\var char starpu_worker_collection::is_unblocked[STARPU_NMAXWORKERS]
        todo
\var char starpu_worker_collection::is_master[STARPU_NMAXWORKERS]
        todo
\var unsigned starpu_worker_collection::nworkers
        The number of workers in the collection
\var enum starpu_worker_collection_type starpu_worker_collection::type
        The type of structure
\var unsigned (*starpu_worker_collection::has_next)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
        Check if there is another element in collection
\var int (*starpu_worker_collection::get_next)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
        Return the next element in the collection
\var int (*starpu_worker_collection::add)(struct starpu_worker_collection *workers, int worker)
        Add a new element in the collection
\var int (*starpu_worker_collection::remove)(struct starpu_worker_collection *workers, int worker)
        Remove an element from the collection
\var void (*starpu_worker_collection::init)(struct starpu_worker_collection *workers)
        Initialize the collection
\var void (*starpu_worker_collection::deinit)(struct starpu_worker_collection *workers)
        Deinitialize the colection
\var void (*starpu_worker_collection::init_iterator)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
        Initialize the cursor if there is one
\var void (*starpu_worker_collection::init_iterator_for_parallel_tasks)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it, struct starpu_task *task);
        todo

\enum starpu_worker_collection_type
\ingroup API_Workers_Properties
Types of structures the worker collection can implement
\var starpu_worker_collection_type::STARPU_WORKER_LIST
    The collection is an array
\var starpu_worker_collection_type::STARPU_WORKER_TREE
    The collection is a tree

\struct starpu_sched_ctx_iterator
\ingroup API_Workers_Properties
Structure needed to iterate on the collection
\var int starpu_sched_ctx_iterator::cursor
    The index of the current worker in the collection, needed when
    iterating on the collection.

\fn unsigned starpu_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of workers (i.e. processing units executing StarPU
tasks). The returned value should be at most \ref STARPU_NMAXWORKERS.

\fn int starpu_worker_get_count_by_type(enum starpu_worker_archtype type)
\ingroup API_Workers_Properties
Return the number of workers of \p type. A positive (or
<c>NULL</c>) value is returned in case of success, <c>-EINVAL</c>
indicates that \p type is not valid otherwise.

\fn unsigned starpu_cpu_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of CPUs controlled by StarPU. The returned value should be at most \ref STARPU_MAXCPUS.

\fn unsigned starpu_cuda_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of CUDA devices controlled by StarPU. The returned value should be at most \ref STARPU_MAXCUDADEVS.

\fn unsigned starpu_mic_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of MIC workers controlled by StarPU.

\fn unsigned starpu_mic_device_get_count(void)
\ingroup API_Workers_Properties
Return the number of MIC devices controlled by StarPU. The returned value should be at most \ref STARPU_MAXMICDEVS.

\fn unsigned starpu_mpi_ms_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of MPI Master Slave workers controlled by StarPU.

\fn unsigned starpu_scc_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of SCC devices controlled by StarPU. The returned value should be at most \ref STARPU_MAXSCCDEVS.

\fn unsigned starpu_opencl_worker_get_count(void)
\ingroup API_Workers_Properties
Return the number of OpenCL devices controlled by StarPU. The returned value should be at most \ref STARPU_MAXOPENCLDEVS.

\fn int starpu_worker_get_id(void)
\ingroup API_Workers_Properties
Return the identifier of the current worker, i.e the one associated to
the calling thread. The returned value is either -1 if the current
context is not a StarPU worker (i.e. when called from the application
outside a task or a callback), or an integer between 0 and
starpu_worker_get_count() - 1.

\fn unsigned starpu_worker_get_id_check(void)
\ingroup API_Workers_Properties
Similar to starpu_worker_get_id(), but abort when called from outside
a worker (i.e. when starpu_worker_get_id() would return -1).

\fn unsigned starpu_worker_get_ids_by_type(enum starpu_worker_archtype type, int *workerids, unsigned maxsize)
\ingroup API_Workers_Properties
Get the list of identifiers of workers of \p type. Fill the array \p
workerids with the identifiers of the \p workers. The argument \p
maxsize indicates the size of the array \p workerids. The returned
value gives the number of identifiers that were put in the array.
<c>-ERANGE</c> is returned is \p maxsize is lower than the number of workers
with the appropriate type: in that case, the array is filled with the
\p maxsize first elements. To avoid such overflows, the value of maxsize
can be chosen by the means of the function
starpu_worker_get_count_by_type(), or by passing a value greater or
equal to \ref STARPU_NMAXWORKERS.

\fn int starpu_worker_get_by_type(enum starpu_worker_archtype type, int num)
\ingroup API_Workers_Properties
Return the identifier of the \p num -th worker that has the
specified \p type. If there is no such worker, -1 is returned.

\fn int starpu_worker_get_by_devid(enum starpu_worker_archtype type, int devid)
\ingroup API_Workers_Properties
Return the identifier of the worker that has the specified \p type
and device id \p devid (which may not be the n-th, if some
devices are skipped for instance). If there is no such worker, -1 is
returned.

\fn int starpu_worker_get_devid(int id)
\ingroup API_Workers_Properties
Return the device id of the worker \p id. The
worker should be identified with the value returned by the
starpu_worker_get_id() function. In the case of a CUDA worker, this
device identifier is the logical device identifier exposed by CUDA
(used by the function \c cudaGetDevice() for instance). The device
identifier of a CPU worker is the logical identifier of the core on
which the worker was bound; this identifier is either provided by the
OS or by the library <c>hwloc</c> in case it is available.

\fn enum starpu_worker_archtype starpu_worker_get_type(int id)
\ingroup API_Workers_Properties
Return the type of processing unit associated to the worker \p id. The
worker identifier is a value returned by the function
starpu_worker_get_id()). The returned value indicates the architecture
of the worker: ::STARPU_CPU_WORKER for a CPU core,
::STARPU_CUDA_WORKER for a CUDA device, and ::STARPU_OPENCL_WORKER for
a OpenCL device. The value returned for an invalid identifier is
unspecified.

\fn void starpu_worker_get_name(int id, char *dst, size_t maxlen)
\ingroup API_Workers_Properties
Allow to get the name of the worker \p id. StarPU associates a unique
human readable string to each processing unit. This function copies at
most the \p maxlen first bytes of the unique string associated to the
worker \p id into the \p dst buffer. The caller is responsible for
ensuring that \p dst is a valid pointer to a buffer of \p maxlen bytes
at least. Calling this function on an invalid identifier results in an
unspecified behaviour.

\fn void starpu_worker_display_names(FILE *output, enum starpu_worker_archtype type)
\ingroup API_Workers_Properties
Display on \p output the list (if any) of all the workers of the given
\p type.

\fn unsigned starpu_worker_get_memory_node(unsigned workerid)
\ingroup API_Workers_Properties
Return the identifier of the memory node associated to the worker
identified by \p workerid.

\fn enum starpu_node_kind starpu_node_get_kind(unsigned node)
\ingroup API_Workers_Properties
Return the type of \p node as defined by
::starpu_node_kind. For example, when defining a new data interface,
this function should be used in the allocation function to determine
on which device the memory needs to be allocated.

\fn char *starpu_worker_get_type_as_string(enum starpu_worker_archtype type)
\ingroup API_Workers_Properties
Return worker \p type as a string.

\fn void _starpu_worker_request_blocking_in_parallel(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Send a request to \p worker to block, before a parallel task is about
to begin. The sched mutex of \p worker must be held before calling
this function.

\fn void _starpu_worker_request_unblocking_in_parallel(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Send a request to \p worker to unblock, after a parallel task is
complete. The sched mutex of \p worker must be held before calling
this function.

\fn void _starpu_worker_process_block_in_parallel_requests(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Called by the \p worker to process incoming requests to block or
unblock on parallel task boundaries. The sched mutex of \p worker must
be held before calling this function.

\fn void _starpu_worker_enter_sched_op(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Mark the beginning of a scheduling operation by \p worker. No worker
blocking operations on parallel tasks and no scheduling context change
operations must be performed on contexts containing \p worker, on
contexts about to add \p worker and on contexts about to remove \p
worker, while the scheduling operation is in process. The sched mutex
of \p worker may only be acquired permanently by another thread when
no scheduling operation is in process, or when a scheduling operation
is in process _and_ <c>worker->state_relax_refcnt!=0</>. If a
scheduling operation is in process _and_
<c>worker->state_relax_refcnt==0</c>, a thread other than \p worker
must wait on condition <c>worker->sched_cond</> for
<c>worker->state_relax_refcnt!=0</> to become true, before acquiring
\p worker sched mutex permanently. The sched mutex of \p worker must
be held before calling this function.

\fn void _starpu_worker_leave_sched_op(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Mark the end of a scheduling operation by \p worker. The sched mutex
of \p worker must be held before calling this function.

\fn int _starpu_worker_sched_op_pending(void)
\ingroup API_Workers_Properties
Return \c !0 if current worker has a scheduling operation in progress,
and \c 0 otherwise.

\fn void _starpu_worker_enter_changing_ctx_op(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Must be called before altering a context related to worker \p worker
whether about adding \p worker to a context, removing it from a
context or modifying the set of workers of a context of which \p
worker is a member, to mark the beginning of a context change
operation. The sched mutex of \p worker must be held before calling
this function.

\fn void _starpu_worker_leave_changing_ctx_op(struct _starpu_worker * const worker)
\ingroup API_Workers_Properties
Mark the end of a context change operation. The sched mutex of \p
worker must be held before calling this function.

\fn void _starpu_worker_relax_on(void)
\ingroup API_Workers_Properties
Allow other threads and workers to temporarily observe the current
worker state, even though it is performing a scheduling operation.
Must be called by a worker before performing a potentially blocking
call such as acquiring a mutex other than its own sched_mutex. This
function increases \c state_relax_refcnt from the current worker. No
more than <c>UINT_MAX-1</c> nested relax_on calls should performed on
the same worker. This function is automatically called by \ref
_starpu_worker_lock to relax the caller worker state while attempting
to lock the targer worker.

\fn void _starpu_worker_relax_on(void)
\ingroup API_Workers_Properties
Must be called after a potentially blocking call is complete, to
restore the relax state in place before the corresponding relax_on.
Decreases \c state_relax_refcnt. Calls to \ref _starpu_worker_relax_on
and \c _starpu_worker_relax_off must be well parenthesized. This
function is automatically called by \ref _starpu_worker_unlock after the 
target worker has been unlocked.

\fn int _starpu_worker_get_relax_state(void)
\ingroup API_Workers_Properties
Returns \c !0 if the current worker \c state_relax_refcnt!=0 and \c 0
otherwise.

\fn void _starpu_worker_lock(int workerid)
\ingroup API_Workers_Properties
Acquire the sched mutex of \p workerid. If the caller is a worker,
distinct from \p workerid, the caller worker automatically enter relax
state while acquiring the target worker lock.

\fn int _starpu_worker_trylock(int workerid)
\ingroup API_Workers_Properties
Attempt to acquire the sched mutex of \p workerid. Returns \c 0 if
successful, \c !0 if \p workerid sched mutex is held or the
corresponding worker is not in relaxed stated.
If the caller is a worker, distinct from \p workerid, the caller
worker automatically enter relax state if successfully acquiring the target
worker lock.

\fn void _starpu_worker_unlock(int workerid)
\ingroup API_Workers_Properties
Release the previously acquired sched mutex of \p workerid. Restore
the relaxed state of the caller worker if needed.

\fn void _starpu_worker_lock_self(void)
\ingroup API_Workers_Properties
Acquire the current worker sched mutex.

\fn void _starpu_worker_unlock_self(void)
\ingroup API_Workers_Properties
Release the current worker sched mutex.

\fn int _starpu_wake_worker_relax(int workerid)
\ingroup API_Workers_Properties
Wake up \p workerid while temporarily entering the current worker
relaxed state if needed during the waiting process.

\fn void _starpu_worker_refuse_task(struct _starpu_worker *worker, struct starpu_task *task)
\ingroup API_Workers_Properties
Allow a worker pulling a task it cannot execute to properly refuse it
and send it back to the scheduler.

*/