|
|
@@ -1277,7 +1277,7 @@ transfers, which are assumed to be completely overlapped.
|
|
|
StarPU provides the wrapper function @code{starpu_insert_task} to ease
|
|
|
the creation and submission of tasks.
|
|
|
|
|
|
-@deftypefun void starpu_insert_task (starpu_codelet *cl, ...)
|
|
|
+@deftypefun void starpu_insert_task (starpu_codelet *@var{cl}, ...)
|
|
|
Create and submit a task corresponding to @var{cl} with the following
|
|
|
arguments. The argument list must be zero-terminated.
|
|
|
|
|
|
@@ -2664,7 +2664,7 @@ StarPU tasks). The returned value should be at most @code{STARPU_NMAXWORKERS}.
|
|
|
|
|
|
@node starpu_worker_get_count_by_type
|
|
|
@subsection @code{starpu_worker_get_count_by_type} -- Get the number of processing units of a given type
|
|
|
-@deftypefun int starpu_worker_get_count_by_type(enum starpu_archtype type);
|
|
|
+@deftypefun int starpu_worker_get_count_by_type(enum starpu_archtype @var{type});
|
|
|
Returns the number of workers of the type indicated by the argument. A positive
|
|
|
(or null) value is returned in case of success, @code{-EINVAL} indicates that
|
|
|
the type is not valid otherwise.
|
|
|
@@ -2709,7 +2709,7 @@ an integer between 0 and @code{starpu_worker_get_count() - 1}.
|
|
|
|
|
|
@node starpu_worker_get_ids_by_type
|
|
|
@subsection @code{starpu_worker_get_ids_by_type} -- Get the list of identifiers of workers with a given type
|
|
|
-@deftypefun int starpu_worker_get_ids_by_type(enum starpu_archtype type, int *workerids, int maxsize);
|
|
|
+@deftypefun int starpu_worker_get_ids_by_type(enum starpu_archtype @var{type}, int *@var{workerids}, int @var{maxsize});
|
|
|
Fill the workerids array with the identifiers of the workers that have the type
|
|
|
indicated in the first argument. The maxsize argument indicates the size of the
|
|
|
workids array. The returned value gives the number of identifiers that were put
|
|
|
@@ -2722,7 +2722,7 @@ by passing a value greater or equal to @code{STARPU_NMAXWORKERS}.
|
|
|
|
|
|
@node starpu_worker_get_devid
|
|
|
@subsection @code{starpu_worker_get_devid} -- Get the device identifier of a worker
|
|
|
-@deftypefun int starpu_worker_get_devid(int id);
|
|
|
+@deftypefun int starpu_worker_get_devid(int @var{id});
|
|
|
This functions returns the device id of the worker associated to an identifier
|
|
|
(as returned by the @code{starpu_worker_get_id} function). In the case of a
|
|
|
CUDA worker, this device identifier is the logical device identifier exposed by
|
|
|
@@ -2734,7 +2734,7 @@ worker was bound; this identifier is either provided by the OS or by the
|
|
|
|
|
|
@node starpu_worker_get_type
|
|
|
@subsection @code{starpu_worker_get_type} -- Get the type of processing unit associated to a worker
|
|
|
-@deftypefun enum starpu_archtype starpu_worker_get_type(int id);
|
|
|
+@deftypefun {enum starpu_archtype} starpu_worker_get_type(int @var{id});
|
|
|
This function returns the type of worker associated to an identifier (as
|
|
|
returned by the @code{starpu_worker_get_id} function). The returned value
|
|
|
indicates the architecture of the worker: @code{STARPU_CPU_WORKER} for a CPU
|
|
|
@@ -2747,7 +2747,7 @@ identifier is unspecified.
|
|
|
@node starpu_worker_get_name
|
|
|
@subsection @code{starpu_worker_get_name} -- Get the name of a worker
|
|
|
|
|
|
-@deftypefun void starpu_worker_get_name(int id, char *dst, size_t maxlen);
|
|
|
+@deftypefun void starpu_worker_get_name(int @var{id}, char *@var{dst}, size_t @var{maxlen});
|
|
|
StarPU associates a unique human readable string to each processing unit. This
|
|
|
function copies at most the @code{maxlen} first bytes of the unique string
|
|
|
associated to a worker identified by its identifier @code{id} into the
|
|
|
@@ -2758,7 +2758,7 @@ function on an invalid identifier results in an unspecified behaviour.
|
|
|
|
|
|
@node starpu_worker_get_memory_node
|
|
|
@subsection @code{starpu_worker_get_memory_node} -- Get the memory node of a worker
|
|
|
-@deftypefun unsigned starpu_worker_get_memory_node(unsigned workerid);
|
|
|
+@deftypefun unsigned starpu_worker_get_memory_node(unsigned @var{workerid});
|
|
|
This function returns the identifier of the memory node associated to the
|
|
|
worker identified by @code{workerid}.
|
|
|
@end deftypefun
|
|
|
@@ -2790,7 +2790,7 @@ design their own data interfaces if required.
|
|
|
|
|
|
@node starpu_malloc
|
|
|
@subsection @code{starpu_malloc} -- Allocate data and pin it
|
|
|
-@deftypefun int starpu_malloc(void **A, size_t dim);
|
|
|
+@deftypefun int starpu_malloc(void **@var{A}, size_t @var{dim});
|
|
|
This function allocates data of the given size. It will also try to pin it in
|
|
|
CUDA or OpenGL, so that data transfers from this buffer can be asynchronous, and
|
|
|
thus permit data transfer and computation overlapping. The allocated buffer must
|
|
|
@@ -2860,7 +2860,7 @@ the data that is accessible from the current processing unit.
|
|
|
|
|
|
@node starpu_data_register
|
|
|
@subsection @code{starpu_data_register} -- Register a piece of data to StarPU
|
|
|
-@deftypefun void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node, void *interface, struct starpu_data_interface_ops_t *ops);
|
|
|
+@deftypefun void starpu_data_register(starpu_data_handle *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, struct starpu_data_interface_ops_t *@var{ops});
|
|
|
Register a piece of data into the handle located at the @code{handleptr}
|
|
|
address. The @code{interface} buffer contains the initial description of the
|
|
|
data in the home node. The @code{ops} argument is a pointer to a structure
|
|
|
@@ -2879,7 +2879,7 @@ matrix) which can be registered by the means of helper functions (e.g.
|
|
|
|
|
|
@node starpu_data_unregister
|
|
|
@subsection @code{starpu_data_unregister} -- Unregister a piece of data from StarPU
|
|
|
-@deftypefun void starpu_data_unregister(starpu_data_handle handle);
|
|
|
+@deftypefun void starpu_data_unregister(starpu_data_handle @var{handle});
|
|
|
This function unregisters a data handle from StarPU. If the data was
|
|
|
automatically allocated by StarPU because the home node was -1, all
|
|
|
automatically allocated buffers are freed. Otherwise, a valid copy of the data
|
|
|
@@ -2890,7 +2890,7 @@ undefined behaviour.
|
|
|
|
|
|
@node starpu_data_invalidate
|
|
|
@subsection @code{starpu_data_invalidate} -- Invalidate all data replicates
|
|
|
-@deftypefun void starpu_data_invalidate(starpu_data_handle handle);
|
|
|
+@deftypefun void starpu_data_invalidate(starpu_data_handle @var{handle});
|
|
|
Destroy all replicates of the data handle. After data invalidation, the first
|
|
|
access to the handle must be performed in write-only mode. Accessing an
|
|
|
invalidated data in read-mode results in undefined behaviour.
|
|
|
@@ -2900,7 +2900,7 @@ invalidated data in read-mode results in undefined behaviour.
|
|
|
|
|
|
@node starpu_data_acquire
|
|
|
@subsection @code{starpu_data_acquire} -- Access registered data from the application
|
|
|
-@deftypefun int starpu_data_acquire(starpu_data_handle handle, starpu_access_mode mode);
|
|
|
+@deftypefun int starpu_data_acquire(starpu_data_handle @var{handle}, starpu_access_mode @var{mode});
|
|
|
The application must call this function prior to accessing registered data from
|
|
|
main memory outside tasks. StarPU ensures that the application will get an
|
|
|
up-to-date copy of the data in main memory located where the data was
|
|
|
@@ -2920,7 +2920,7 @@ tasks or from their callbacks (in that case, @code{starpu_data_acquire} returns
|
|
|
|
|
|
@node starpu_data_acquire_cb
|
|
|
@subsection @code{starpu_data_acquire_cb} -- Access registered data from the application asynchronously
|
|
|
-@deftypefun int starpu_data_acquire_cb(starpu_data_handle handle, starpu_access_mode mode, void (*callback)(void *), void *arg);
|
|
|
+@deftypefun int starpu_data_acquire_cb(starpu_data_handle @var{handle}, starpu_access_mode @var{mode}, void (*@var{callback})(void *), void *@var{arg});
|
|
|
@code{starpu_data_acquire_cb} is the asynchronous equivalent of
|
|
|
@code{starpu_data_release}. When the data specified in the first argument is
|
|
|
available in the appropriate access mode, the callback function is executed.
|
|
|
@@ -2936,14 +2936,14 @@ returns 0.
|
|
|
|
|
|
@node starpu_data_release
|
|
|
@subsection @code{starpu_data_release} -- Release registered data from the application
|
|
|
-@deftypefun void starpu_data_release(starpu_data_handle handle);
|
|
|
+@deftypefun void starpu_data_release(starpu_data_handle @var{handle});
|
|
|
This function releases the piece of data acquired by the application either by
|
|
|
@code{starpu_data_acquire} or by @code{starpu_data_acquire_cb}.
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_data_set_wt_mask
|
|
|
@subsection @code{starpu_data_set_wt_mask} -- Set the Write-Through mask
|
|
|
-@deftypefun void starpu_data_set_wt_mask(starpu_data_handle handle, uint32_t wt_mask);
|
|
|
+@deftypefun void starpu_data_set_wt_mask(starpu_data_handle @var{handle}, uint32_t @var{wt_mask});
|
|
|
This function sets the write-through mask of a given data, i.e. a bitmask of
|
|
|
nodes where the data should be always replicated after modification.
|
|
|
@end deftypefun
|
|
|
@@ -2951,7 +2951,7 @@ nodes where the data should be always replicated after modification.
|
|
|
@node starpu_data_prefetch_on_node
|
|
|
@subsection @code{starpu_data_prefetch_on_node} -- Prefetch data to a given node
|
|
|
|
|
|
-@deftypefun int starpu_data_prefetch_on_node(starpu_data_handle handle, unsigned node, unsigned async)
|
|
|
+@deftypefun int starpu_data_prefetch_on_node(starpu_data_handle @var{handle}, unsigned @var{node}, unsigned @var{async})
|
|
|
Issue a prefetch request for a given data to a given node, i.e.
|
|
|
requests that the data be replicated to the given node, so that it is available
|
|
|
there for tasks. If the @code{async} parameter is 0, the call will block until
|
|
|
@@ -3075,7 +3075,7 @@ starpu_block_data_register(&block_handle, 0, (uintptr_t)block,
|
|
|
@node BCSR Interface for Sparse Matrices (Blocked Compressed Sparse Row Representation)
|
|
|
@subsection BCSR Interface for Sparse Matrices (Blocked Compressed Sparse Row Representation)
|
|
|
|
|
|
-@deftypefun void starpu_bcsr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize);
|
|
|
+@deftypefun void starpu_bcsr_data_register(starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, uint32_t @var{r}, uint32_t @var{c}, size_t @var{elemsize});
|
|
|
This variant of @code{starpu_data_register} uses the BCSR sparse matrix interface.
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
@@ -3083,7 +3083,7 @@ TODO
|
|
|
@node CSR Interface for Sparse Matrices (Compressed Sparse Row Representation)
|
|
|
@subsection CSR Interface for Sparse Matrices (Compressed Sparse Row Representation)
|
|
|
|
|
|
-@deftypefun void starpu_csr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize);
|
|
|
+@deftypefun void starpu_csr_data_register(starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, size_t @var{elemsize});
|
|
|
This variant of @code{starpu_data_register} uses the CSR sparse matrix interface.
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
@@ -3225,38 +3225,38 @@ list can be found in @code{starpu_data_filters.h} .
|
|
|
@node Partitioning BCSR Data
|
|
|
@subsubsection Partitioning BCSR Data
|
|
|
|
|
|
-@deftypefun void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_canonical_block_filter_bcsr(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_vertical_block_filter_func_csr(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node Partitioning BLAS interface
|
|
|
@subsubsection Partitioning BLAS interface
|
|
|
|
|
|
-@deftypefun void starpu_block_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_block_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a dense Matrix into horizontal blocks.
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_vertical_block_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a dense Matrix into vertical blocks.
|
|
|
@end deftypefun
|
|
|
|
|
|
@node Partitioning Vector Data
|
|
|
@subsubsection Partitioning Vector Data
|
|
|
|
|
|
-@deftypefun void starpu_block_filter_func_vector(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_block_filter_func_vector(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a vector into blocks of the same size.
|
|
|
@end deftypefun
|
|
|
|
|
|
|
|
|
-@deftypefun void starpu_vector_list_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_vector_list_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a vector into blocks of sizes given in @code{filter_arg_ptr}.
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_vector_divide_in_2_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a vector into two blocks, the first block size being given in @code{filter_arg}.
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -3264,7 +3264,7 @@ This partitions a vector into two blocks, the first block size being given in @c
|
|
|
@node Partitioning Block Data
|
|
|
@subsubsection Partitioning Block Data
|
|
|
|
|
|
-@deftypefun void starpu_block_filter_func_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
|
|
|
+@deftypefun void starpu_block_filter_func_block(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
|
|
|
This partitions a 3D matrix along the X axis.
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -3455,7 +3455,7 @@ called by @code{starpu_task_create}. By default, tasks initialized with
|
|
|
constant @code{STARPU_TASK_INITIALIZER}.
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun {struct starpu_task *} starpu_task_create ()
|
|
|
+@deftypefun {struct starpu_task *} starpu_task_create (void)
|
|
|
Allocate a task structure and initialize it with default values. Tasks
|
|
|
allocated dynamically with @code{starpu_task_create} are automatically freed when the
|
|
|
task is terminated. If the destroy flag is explicitly unset, the resources used
|
|
|
@@ -3502,11 +3502,11 @@ means that there is no worker able to process this task (e.g. there is no GPU
|
|
|
available and this task is only implemented for CUDA devices).
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun int starpu_task_wait_for_all ()
|
|
|
+@deftypefun int starpu_task_wait_for_all (void)
|
|
|
This function blocks until all the tasks that were submitted are terminated.
|
|
|
@end deftypefun
|
|
|
|
|
|
-@deftypefun {struct starpu_task *} starpu_get_current_task ()
|
|
|
+@deftypefun {struct starpu_task *} starpu_get_current_task (void)
|
|
|
This function returns the task currently executed by the worker, or
|
|
|
NULL if it is called either from a thread that is not a task or simply
|
|
|
because there is no task being executed at the moment.
|
|
|
@@ -3535,7 +3535,7 @@ Output on @code{stderr} some statistics on the codelet @var{cl}.
|
|
|
|
|
|
@node starpu_task_declare_deps_array
|
|
|
@subsection @code{starpu_task_declare_deps_array} -- Declare task dependencies
|
|
|
-@deftypefun void starpu_task_declare_deps_array(struct starpu_task *task, unsigned ndeps, struct starpu_task *task_array[]);
|
|
|
+@deftypefun void starpu_task_declare_deps_array(struct starpu_task *@var{task}, unsigned @var{ndeps}, struct starpu_task *@var{task_array[]});
|
|
|
Declare task dependencies between a @code{task} and an array of tasks of length
|
|
|
@code{ndeps}. This function must be called prior to the submission of the task,
|
|
|
but it may called after the submission or the execution of the tasks in the
|
|
|
@@ -3620,7 +3620,7 @@ starpu_tag_declare_deps_array((starpu_tag_t)0x1, 2, tag_array);
|
|
|
|
|
|
@node starpu_tag_wait
|
|
|
@subsection @code{starpu_tag_wait} -- Block until a Tag is terminated
|
|
|
-@deftypefun void starpu_tag_wait(starpu_tag_t id);
|
|
|
+@deftypefun void starpu_tag_wait(starpu_tag_t @var{id});
|
|
|
This function blocks until the task associated to tag @code{id} has been
|
|
|
executed. This is a blocking call which must therefore not be called within
|
|
|
tasks or callbacks, but only from the application directly. It is possible to
|
|
|
@@ -3633,7 +3633,7 @@ data structure was freed (e.g. if the @code{destroy} flag of the
|
|
|
|
|
|
@node starpu_tag_wait_array
|
|
|
@subsection @code{starpu_tag_wait_array} -- Block until a set of Tags is terminated
|
|
|
-@deftypefun void starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id);
|
|
|
+@deftypefun void starpu_tag_wait_array(unsigned @var{ntags}, starpu_tag_t *@var{id});
|
|
|
This function is similar to @code{starpu_tag_wait} except that it blocks until
|
|
|
@emph{all} the @code{ntags} tags contained in the @code{id} array are
|
|
|
terminated.
|
|
|
@@ -3641,7 +3641,7 @@ terminated.
|
|
|
|
|
|
@node starpu_tag_remove
|
|
|
@subsection @code{starpu_tag_remove} -- Destroy a Tag
|
|
|
-@deftypefun void starpu_tag_remove(starpu_tag_t id);
|
|
|
+@deftypefun void starpu_tag_remove(starpu_tag_t @var{id});
|
|
|
This function releases the resources associated to tag @code{id}. It can be
|
|
|
called once the corresponding task has been executed and when there is
|
|
|
no other tag that depend on this tag anymore.
|
|
|
@@ -3649,7 +3649,7 @@ no other tag that depend on this tag anymore.
|
|
|
|
|
|
@node starpu_tag_notify_from_apps
|
|
|
@subsection @code{starpu_tag_notify_from_apps} -- Feed a Tag explicitly
|
|
|
-@deftypefun void starpu_tag_notify_from_apps(starpu_tag_t id);
|
|
|
+@deftypefun void starpu_tag_notify_from_apps(starpu_tag_t @var{id});
|
|
|
This function explicitly unlocks tag @code{id}. It may be useful in the
|
|
|
case of applications which execute part of their computation outside StarPU
|
|
|
tasks (e.g. third-party libraries). It is also provided as a
|
|
|
@@ -3677,7 +3677,7 @@ are also inserted in the case of data accesses from the application.
|
|
|
|
|
|
@node starpu_data_set_default_sequential_consistency_flag
|
|
|
@subsection @code{starpu_data_set_default_sequential_consistency_flag} -- Set default sequential consistency flag
|
|
|
-@deftypefun void starpu_data_set_default_sequential_consistency_flag(unsigned flag);
|
|
|
+@deftypefun void starpu_data_set_default_sequential_consistency_flag(unsigned @var{flag});
|
|
|
Set the default sequential consistency flag. If a non-zero value is passed, a
|
|
|
sequential data consistency will be enforced for all handles registered after
|
|
|
this function call, otherwise it is disabled. By default, StarPU enables
|
|
|
@@ -3694,7 +3694,7 @@ This function returns the current default sequential consistency flag.
|
|
|
|
|
|
@node starpu_data_set_sequential_consistency_flag
|
|
|
@subsection @code{starpu_data_set_sequential_consistency_flag} -- Set data sequential consistency mode
|
|
|
-@deftypefun void starpu_data_set_sequential_consistency_flag(starpu_data_handle handle, unsigned flag);
|
|
|
+@deftypefun void starpu_data_set_sequential_consistency_flag(starpu_data_handle @var{handle}, unsigned @var{flag});
|
|
|
Select the data consistency mode associated to a data handle. The consistency
|
|
|
mode set using this function has the priority over the default mode which can
|
|
|
be set with @code{starpu_data_set_sequential_consistency_flag}.
|
|
|
@@ -3712,19 +3712,19 @@ be set with @code{starpu_data_set_sequential_consistency_flag}.
|
|
|
|
|
|
@node starpu_load_history_debug
|
|
|
@subsection @code{starpu_load_history_debug}
|
|
|
-@deftypefun int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel_t *model);
|
|
|
+@deftypefun int starpu_load_history_debug(const char *@var{symbol}, struct starpu_perfmodel_t *@var{model});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_perfmodel_debugfilepath
|
|
|
@subsection @code{starpu_perfmodel_debugfilepath}
|
|
|
-@deftypefun void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, char *path, size_t maxlen);
|
|
|
+@deftypefun void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *@var{model}, enum starpu_perf_archtype @var{arch}, char *@var{path}, size_t @var{maxlen});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_perfmodel_get_arch_name
|
|
|
@subsection @code{starpu_perfmodel_get_arch_name}
|
|
|
-@deftypefun void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype arch, char *archname, size_t maxlen);
|
|
|
+@deftypefun void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype @var{arch}, char *@var{archname}, size_t @var{maxlen});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -3861,31 +3861,31 @@ TODO
|
|
|
|
|
|
@node starpu_bus_get_id
|
|
|
@subsection @code{starpu_bus_get_id}
|
|
|
-@deftypefun int starpu_bus_get_id(int src, int dst);
|
|
|
+@deftypefun int starpu_bus_get_id(int @var{src}, int @var{dst});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_bus_get_src
|
|
|
@subsection @code{starpu_bus_get_src}
|
|
|
-@deftypefun int starpu_bus_get_src(int busid);
|
|
|
+@deftypefun int starpu_bus_get_src(int @var{busid});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_bus_get_dst
|
|
|
@subsection @code{starpu_bus_get_dst}
|
|
|
-@deftypefun int starpu_bus_get_dst(int busid);
|
|
|
+@deftypefun int starpu_bus_get_dst(int @var{busid});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_timing_timespec_delay_us
|
|
|
@subsection @code{starpu_timing_timespec_delay_us}
|
|
|
-@deftypefun double starpu_timing_timespec_delay_us(struct timespec *start, struct timespec *end);
|
|
|
+@deftypefun double starpu_timing_timespec_delay_us(struct timespec *@var{start}, struct timespec *@var{end});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_timing_timespec_to_us
|
|
|
@subsection @code{starpu_timing_timespec_to_us}
|
|
|
-@deftypefun double starpu_timing_timespec_to_us(struct timespec *ts);
|
|
|
+@deftypefun double starpu_timing_timespec_to_us(struct timespec *@var{ts});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -3916,7 +3916,7 @@ TODO
|
|
|
|
|
|
@node starpu_cuda_get_local_stream
|
|
|
@subsection @code{starpu_cuda_get_local_stream} -- Get current worker's CUDA stream
|
|
|
-@deftypefun cudaStream_t *starpu_cuda_get_local_stream(void);
|
|
|
+@deftypefun {cudaStream_t *} starpu_cuda_get_local_stream(void);
|
|
|
StarPU provides a stream for every CUDA device controlled by StarPU. This
|
|
|
function is only provided for convenience so that programmers can easily use
|
|
|
asynchronous operations within codelets without having to create a stream by
|
|
|
@@ -3997,19 +3997,19 @@ relocation purpose for instance).
|
|
|
|
|
|
@node starpu_opencl_load_opencl_from_file
|
|
|
@subsubsection @code{starpu_opencl_load_opencl_from_file} -- Compiling OpenCL source code
|
|
|
-@deftypefun int starpu_opencl_load_opencl_from_file(char *source_file_name, struct starpu_opencl_program *opencl_programs, const char* build_options);
|
|
|
+@deftypefun int starpu_opencl_load_opencl_from_file(char *@var{source_file_name}, struct starpu_opencl_program *@var{opencl_programs}, const char* @var{build_options});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_opencl_load_opencl_from_string
|
|
|
@subsubsection @code{starpu_opencl_load_opencl_from_string} -- Compiling OpenCL source code
|
|
|
-@deftypefun int starpu_opencl_load_opencl_from_string(char *opencl_program_source, struct starpu_opencl_program *opencl_programs, const char* build_options);
|
|
|
+@deftypefun int starpu_opencl_load_opencl_from_string(char *@var{opencl_program_source}, struct starpu_opencl_program *@var{opencl_programs}, const char* @var{build_options});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_opencl_unload_opencl
|
|
|
@subsubsection @code{starpu_opencl_unload_opencl} -- Releasing OpenCL code
|
|
|
-@deftypefun int starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs);
|
|
|
+@deftypefun int starpu_opencl_unload_opencl(struct starpu_opencl_program *@var{opencl_programs});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -4023,13 +4023,13 @@ TODO
|
|
|
|
|
|
@node starpu_opencl_load_kernel
|
|
|
@subsubsection @code{starpu_opencl_load_kernel} -- Loading a kernel
|
|
|
-@deftypefun int starpu_opencl_load_kernel(cl_kernel *kernel, cl_command_queue *queue, struct starpu_opencl_program *opencl_programs, char *kernel_name, int devid)
|
|
|
+@deftypefun int starpu_opencl_load_kernel(cl_kernel *@var{kernel}, cl_command_queue *@var{queue}, struct starpu_opencl_program *@var{opencl_programs}, char *@var{kernel_name}, int @var{devid})
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@node starpu_opencl_relase_kernel
|
|
|
@subsubsection @code{starpu_opencl_release_kernel} -- Releasing a kernel
|
|
|
-@deftypefun int starpu_opencl_release_kernel(cl_kernel kernel);
|
|
|
+@deftypefun int starpu_opencl_release_kernel(cl_kernel @var{kernel});
|
|
|
TODO
|
|
|
@end deftypefun
|
|
|
|
|
|
@@ -4042,7 +4042,7 @@ TODO
|
|
|
|
|
|
@node starpu_opencl_collect_stats
|
|
|
@subsubsection @code{starpu_opencl_collect_stats} -- Collect statistics on a kernel execution
|
|
|
-@deftypefun int starpu_opencl_collect_stats(cl_event event);
|
|
|
+@deftypefun int starpu_opencl_collect_stats(cl_event @var{event});
|
|
|
After termination of the kernels, the OpenCL codelet should call this function
|
|
|
to pass it the even returned by @code{clEnqueueNDRangeKernel}, to let StarPU
|
|
|
collect statistics about the kernel execution (used cycles, consumed power).
|
|
|
@@ -4064,7 +4064,7 @@ nothing yet.
|
|
|
|
|
|
@node starpu_data_cpy
|
|
|
@subsection @code{starpu_data_cpy} -- Copy a data handle into another data handle
|
|
|
-@deftypefun int starpu_data_cpy(starpu_data_handle dst_handle, starpu_data_handle src_handle, int asynchronous, void (*callback_func)(void*), void *callback_arg);
|
|
|
+@deftypefun int starpu_data_cpy(starpu_data_handle @var{dst_handle}, starpu_data_handle @var{src_handle}, int @var{asynchronous}, void (*@var{callback_func})(void*), void *@var{callback_arg});
|
|
|
Copy the content of the @code{src_handle} into the @code{dst_handle} handle.
|
|
|
The @code{asynchronous} parameter indicates whether the function should
|
|
|
block or not. In the case of an asynchronous call, it is possible to
|
|
|
@@ -4079,7 +4079,7 @@ given the @code{callback_arg} pointer as argument.
|
|
|
|
|
|
@node starpu_execute_on_each_worker
|
|
|
@subsection @code{starpu_execute_on_each_worker} -- Execute a function on a subset of workers
|
|
|
-@deftypefun void starpu_execute_on_each_worker(void (*func)(void *), void *arg, uint32_t where);
|
|
|
+@deftypefun void starpu_execute_on_each_worker(void (*@var{func})(void *), void *@var{arg}, uint32_t @var{where});
|
|
|
When calling this method, the offloaded function specified by the first argument is
|
|
|
executed by every StarPU worker that may execute the function.
|
|
|
The second argument is passed to the offloaded function.
|
|
|
@@ -4200,7 +4200,7 @@ Description of the policy (optionnal).
|
|
|
|
|
|
@node starpu_worker_set_sched_condition
|
|
|
@subsection @code{starpu_worker_set_sched_condition} -- Specify the condition variable associated to a worker
|
|
|
-@deftypefun void starpu_worker_set_sched_condition(int workerid, pthread_cond_t *sched_cond, pthread_mutex_t *sched_mutex);
|
|
|
+@deftypefun void starpu_worker_set_sched_condition(int @var{workerid}, pthread_cond_t *@var{sched_cond}, pthread_mutex_t *@var{sched_mutex});
|
|
|
When there is no available task for a worker, StarPU blocks this worker on a
|
|
|
condition variable. This function specifies which condition variable (and the
|
|
|
associated mutex) should be used to block (and to wake up) a worker. Note that
|
|
|
@@ -4213,7 +4213,7 @@ call this function once per worker.
|
|
|
|
|
|
@node starpu_sched_set_min_priority
|
|
|
@subsection @code{starpu_sched_set_min_priority}
|
|
|
-@deftypefun void starpu_sched_set_min_priority(int min_prio);
|
|
|
+@deftypefun void starpu_sched_set_min_priority(int @var{min_prio});
|
|
|
Defines the minimum priority level supported by the scheduling policy. The
|
|
|
default minimum priority level is the same as the default priority level which
|
|
|
is 0 by convention. The application may access that value by calling the
|
|
|
@@ -4224,7 +4224,7 @@ be used directly from the application.
|
|
|
|
|
|
@node starpu_sched_set_max_priority
|
|
|
@subsection @code{starpu_sched_set_max_priority}
|
|
|
-@deftypefun void starpu_sched_set_min_priority(int max_prio);
|
|
|
+@deftypefun void starpu_sched_set_min_priority(int @var{max_prio});
|
|
|
Defines the maximum priority level supported by the scheduling policy. The
|
|
|
default maximum priority level is 1. The application may access that value by
|
|
|
calling the @code{starpu_sched_get_max_priority} function. This function should
|
|
|
@@ -4234,7 +4234,7 @@ should not be used directly from the application.
|
|
|
|
|
|
@node starpu_push_local_task
|
|
|
@subsection @code{starpu_push_local_task}
|
|
|
-@deftypefun int starpu_push_local_task(int workerid, struct starpu_task *task, int back);
|
|
|
+@deftypefun int starpu_push_local_task(int @var{workerid}, struct starpu_task *@var{task}, int @var{back});
|
|
|
The scheduling policy may put tasks directly into a worker's local queue so
|
|
|
that it is not always necessary to create its own queue when the local queue
|
|
|
is sufficient. If "back" not null, the task is put at the back of the queue
|
