doc/doxygen: update documentation

doc/doxygen/chapters/api/codelet_and_tasks.doxy

@@ -12,23 +12,23 @@
 
 \def STARPU_CPU
 \ingroup Codelet_And_Tasks
-\brief This macro is used when setting the field starpu_codelet::where
+This macro is used when setting the field starpu_codelet::where
 to specify the codelet may be executed on a CPU processing unit.
 
 \def STARPU_CUDA
 \ingroup Codelet_And_Tasks
-\brief This macro is used when setting the field starpu_codelet::where
+This macro is used when setting the field starpu_codelet::where
 to specify the codelet may be executed on a CUDA processing unit.
 
 \def STARPU_OPENCL
 \ingroup Codelet_And_Tasks
-\brief This macro is used when setting the field starpu_codelet::where to
+This macro is used when setting the field starpu_codelet::where to
 specify the codelet may be executed on a OpenCL processing unit.
 
 \def STARPU_MULTIPLE_CPU_IMPLEMENTATIONS
 \deprecated
 \ingroup Codelet_And_Tasks
-\brief Setting the field starpu_codelet::cpu_func with this macro
+Setting the field starpu_codelet::cpu_func with this macro
 indicates the codelet will have several implementations. The use of
 this macro is deprecated. One should always only define the field
 starpu_codelet::cpu_funcs.
@@ -36,7 +36,7 @@ starpu_codelet::cpu_funcs.
 \def STARPU_MULTIPLE_CUDA_IMPLEMENTATIONS
 \deprecated
 \ingroup Codelet_And_Tasks
-\brief Setting the field starpu_codelet::cuda_func with this macro
+Setting the field starpu_codelet::cuda_func with this macro
 indicates the codelet will have several implementations. The use of
 this macro is deprecated. One should always only define the field
 starpu_codelet::cuda_funcs.
@@ -44,11 +44,31 @@ starpu_codelet::cuda_funcs.
 \def STARPU_MULTIPLE_OPENCL_IMPLEMENTATIONS
 \deprecated
 \ingroup Codelet_And_Tasks
-\brief Setting the field starpu_codelet::opencl_func with
+Setting the field starpu_codelet::opencl_func with
 this macro indicates the codelet will have several implementations.
 The use of this macro is deprecated. One should always only define the
 field starpu_codelet::opencl_funcs.
 
+\def starpu_cpu_func_t
+\ingroup Codelet_And_Tasks
+CPU implementation of a codelet.
+
+\def starpu_cuda_func_t
+\ingroup Codelet_And_Tasks
+CUDA implementation of a codelet.
+
+\def starpu_opencl_func_t
+\ingroup Codelet_And_Tasks
+OpenCL implementation of a codelet.
+
+\def starpu_mic_func_t
+\ingroup Codelet_And_Tasks
+MIC implementation of a codelet.
+
+\def starpu_scc_func_t
+\ingroup Codelet_And_Tasks
+SCC implementation of a codelet.
+
 \struct starpu_codelet
 \brief The codelet structure describes a kernel that is possibly
 implemented on various targets. For compatibility, make sure to
@@ -183,7 +203,7 @@ purposes.
 
 \fn void starpu_codelet_init(struct starpu_codelet *cl)
 \ingroup Codelet_And_Tasks
-\brief Initialize \p cl with default values. Codelets should
+Initialize \p cl with default values. Codelets should
 preferably be initialized statically as shown in \ref
 Defining_a_Codelet. However such a initialisation is not always
 possible, e.g. when using C++.
@@ -407,7 +427,7 @@ Whether the scheduler has pushed the task on some queue
 
 \fn void starpu_task_init(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief Initialize task with default values. This function is
+Initialize task with default values. This function is
 implicitly called by starpu_task_create(). By default, tasks initialized
 with starpu_task_init() must be deinitialized explicitly with
 starpu_task_clean(). Tasks can also be initialized statically, using
@@ -415,13 +435,13 @@ STARPU_TASK_INITIALIZER.
 
 \def STARPU_TASK_INITIALIZER
 \ingroup Codelet_And_Tasks
-\brief It is possible to initialize statically allocated tasks with
+It is possible to initialize statically allocated tasks with
 this value. This is equivalent to initializing a structure starpu_task
 with the function starpu_task_init() function.
 
 \def STARPU_TASK_GET_HANDLE(struct starpu_task *task, int i)
 \ingroup Codelet_And_Tasks
-\brief Return the \p i th data handle of the given task. If the task
+Return the \p i th data handle of the given task. If the task
 is defined with a static or dynamic number of handles, will either
 return the \p i th element of the field starpu_task::handles or the \p
 i th element of the field starpu_task::dyn_handles (see \ref
@@ -429,7 +449,7 @@ Setting_the_Data_Handles_for_a_Task)
 
 \def STARPU_TASK_SET_HANDLE(struct starpu_task *task, starpu_data_handle_t handle, int i)
 \ingroup Codelet_And_Tasks
-\brief Set the \p i th data handle of the given task with the given
+Set the \p i th data handle of the given task with the given
 dat handle. If the task is defined with a static or dynamic number of
 handles, will either set the \p i th element of the field
 starpu_task::handles or the \p i th element of the field
@@ -438,7 +458,7 @@ Setting_the_Data_Handles_for_a_Task)
 
 \def STARPU_CODELET_GET_MODE(struct starpu_codelet *codelet, int i)
 \ingroup Codelet_And_Tasks
-\brief Return the access mode of the \p i th data handle of the given
+Return the access mode of the \p i th data handle of the given
 codelet. If the codelet is defined with a static or dynamic number of
 handles, will either return the \p i th element of the field
 starpu_codelet::modes or the \p i th element of the field
@@ -447,7 +467,7 @@ Setting_the_Data_Handles_for_a_Task)
 
 \def STARPU_CODELET_SET_MODE(struct starpu_codelet *codelet, enum starpu_data_access_mode mode, int i)
 \ingroup Codelet_And_Tasks
-\brief Set the access mode of the \p i th data handle of the given
+Set the access mode of the \p i th data handle of the given
 codelet. If the codelet is defined with a static or dynamic number of
 handles, will either set the \p i th element of the field
 starpu_codelet::modes or the \p i th element of the field
@@ -456,7 +476,7 @@ Setting_the_Data_Handles_for_a_Task)
 
 \fn struct starpu_task * starpu_task_create(void)
 \ingroup Codelet_And_Tasks
-\brief Allocate a task structure and initialize it with default
+Allocate a task structure and initialize it with default
 values. Tasks allocated dynamically with starpu_task_create() are
 automatically freed when the task is terminated. This means that the
 task pointer can not be used any more once the task is submitted,
@@ -467,12 +487,12 @@ calling starpu_task_destroy().
 
 \fn struct starpu_task * starpu_task_dup(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief Allocate a task structure which is the exact duplicate of the
+Allocate a task structure which is the exact duplicate of the
 given task.
 
 \fn void starpu_task_clean(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief Release all the structures automatically allocated to execute
+Release all the structures automatically allocated to execute
 task, but not the task structure itself and values set by the user
 remain unchanged. It is thus useful for statically allocated tasks for
 instance. It is also useful when users want to execute the same
@@ -484,7 +504,7 @@ manipulates the task after calling the callback).
 
 \fn void starpu_task_destroy(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief Free the resource allocated during starpu_task_create() and
+Free the resource allocated during starpu_task_create() and
 associated with task. This function is already called automatically
 after the execution of a task when the field starpu_task::destroy is
 set, which is the default for tasks created by starpu_task_create().
@@ -493,7 +513,7 @@ undefined behaviour.
 
 \fn int starpu_task_wait(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief This function blocks until \p task has been executed. It is not
+This function blocks until \p task has been executed. It is not
 possible to synchronize with a task more than once. It is not possible
 to wait for synchronous or detached tasks. Upon successful completion,
 this function returns 0. Otherwise, <c>-EINVAL</c> indicates that the
@@ -501,7 +521,7 @@ specified task was either synchronous or detached.
 
 \fn int starpu_task_submit(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief This function submits task to StarPU. Calling this function
+This function submits task to StarPU. Calling this function
 does not mean that the task will be executed immediately as there can
 be data or task (tag) dependencies that are not fulfilled yet: StarPU
 will take care of scheduling this task with respect to such
@@ -519,52 +539,57 @@ starpu_task::synchronous is set to 0.
 
 \fn int starpu_task_wait_for_all(void)
 \ingroup Codelet_And_Tasks
-\brief This function blocks until all the tasks that were submitted
+This function blocks until all the tasks that were submitted
 (to the current context or the global one if there aren't any) are
 terminated. It does not destroy these tasks.
 
 \fn int starpu_task_wait_for_all_in_ctx(unsigned sched_ctx_id)
 \ingroup Codelet_And_Tasks
-\brief This function waits until all the tasks that were already
+This function waits until all the tasks that were already
 submitted to the context \p sched_ctx_id have been executed
 
 \fn int starpu_task_nready(void)
 \ingroup Codelet_And_Tasks
-\brief TODO
+TODO
 
-\brief int starpu_task_nsubmitted(void)
+\fn int starpu_task_nsubmitted(void)
 \ingroup Codelet_And_Tasks
 Return the number of submitted tasks which have not completed yet.
 
 \fn int starpu_task_nready(void)
 \ingroup Codelet_And_Tasks
-\brief Return the number of submitted tasks which are ready for
+Return the number of submitted tasks which are ready for
 execution are already executing. It thus does not include tasks
 waiting for dependencies.
 
 \fn struct starpu_task * starpu_task_get_current(void)
 \ingroup Codelet_And_Tasks
-\brief This function returns the task currently executed by the
+This function returns the task currently executed by the
 worker, or <c>NULL</c> 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.
 
 \fn void starpu_codelet_display_stats(struct starpu_codelet *cl)
 \ingroup Codelet_And_Tasks
-\brief Output on stderr some statistics on the codelet \p cl.
+Output on stderr some statistics on the codelet \p cl.
 
 \fn int starpu_task_wait_for_no_ready(void)
 \ingroup Codelet_And_Tasks
-\brief This function waits until there is no more ready task.
+This function waits until there is no more ready task.
 
 \fn void starpu_task_set_implementation(struct starpu_task *task, unsigned impl)
 \ingroup Codelet_And_Tasks
-\brief This function should be called by schedulers to specify the
+This function should be called by schedulers to specify the
 codelet implementation to be executed when executing the task.
 
 \fn unsigned starpu_task_get_implementation(struct starpu_task *task)
 \ingroup Codelet_And_Tasks
-\brief This function return the codelet implementation to be executed
+This function return the codelet implementation to be executed
 when executing the task.
 
+\fn void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t *deps,	void (*callback)(void *), void *callback_arg)
+\ingroup Codelet_And_Tasks
+This creates (and submits) an empty task that unlocks a tag once all
+its dependencies are fulfilled.
+
 
 */

doc/doxygen/chapters/api/cuda_extensions.doxy

@@ -10,13 +10,13 @@
 
 \def STARPU_USE_CUDA
 \ingroup CUDA_Extensions
-\brief This macro is defined when StarPU has been installed with CUDA
+This macro is defined when StarPU has been installed with CUDA
 support. It should be used in your code to detect the availability of
 CUDA as shown in Full source code for the 'Scaling a Vector' example.
 
 \fn cudaStream_t starpu_cuda_get_local_stream(void)
 \ingroup CUDA_Extensions
-\brief This function gets the current worker’s CUDA stream. StarPU
+This function gets the current worker’s CUDA stream. 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
@@ -28,20 +28,20 @@ overlapped.
 
 \fn const struct cudaDeviceProp * starpu_cuda_get_device_properties(unsigned workerid)
 \ingroup CUDA_Extensions
-\brief This function returns a pointer to device properties for worker
+This function returns a pointer to device properties for worker
 \p workerid (assumed to be a CUDA worker).
 
 \fn void starpu_cuda_report_error(const char *func, const char *file, int line, cudaError_t status)
 \ingroup CUDA_Extensions
-\brief Report a CUDA error.
+Report a CUDA error.
 
 \def STARPU_CUDA_REPORT_ERROR (cudaError_t status)
 \ingroup CUDA_Extensions
-\brief Calls starpu_cuda_report_error(), passing the current function, file and line position.
+Calls starpu_cuda_report_error(), passing the current function, file and line position.
 
 \fn int starpu_cuda_copy_async_sync (void *src_ptr, unsigned src_node, void *dst_ptr, unsigned dst_node, size_t ssize, cudaStream_t stream, enum cudaMemcpyKind kind)
 \ingroup CUDA_Extensions
-\brief Copy \p ssize bytes from the pointer \p src_ptr on \p src_node
+Copy \p ssize bytes from the pointer \p src_ptr on \p src_node
 to the pointer \p dst_ptr on \p dst_node. The function first tries to
 copy the data asynchronous (unless stream is <c>NULL</c>). If the
 asynchronous copy fails or if stream is <c>NULL</c>, it copies the
@@ -51,13 +51,13 @@ copy was successful, or fails otherwise.
 
 \fn void starpu_cuda_set_device(unsigned devid)
 \ingroup CUDA_Extensions
-\brief Calls cudaSetDevice(devid) or cudaGLSetGLDevice(devid),
+Calls cudaSetDevice(devid) or cudaGLSetGLDevice(devid),
 according to whether \p devid is among the field
 starpu_conf::cuda_opengl_interoperability.
 
 \fn void starpu_cublas_init(void)
 \ingroup CUDA_Extensions
-\brief This function initializes CUBLAS on every CUDA device. The
+This function initializes CUBLAS on every CUDA device. The
 CUBLAS library must be initialized prior to any CUBLAS call. Calling
 starpu_cublas_init() will initialize CUBLAS on every CUDA device
 controlled by StarPU. This call blocks until CUBLAS has been properly
@@ -65,16 +65,16 @@ initialized on every device.
 
 \fn void starpu_cublas_shutdown(void)
 \ingroup CUDA_Extensions
-\brief This function synchronously deinitializes the CUBLAS library on
+This function synchronously deinitializes the CUBLAS library on
 every CUDA device.
 
 \fn void starpu_cublas_report_error(const char *func, const char *file, int line, cublasStatus status)
 \ingroup CUDA_Extensions
-\brief Report a cublas error.
+Report a cublas error.
 
 \def STARPU_CUBLAS_REPORT_ERROR (cublasStatus status)
 \ingroup CUDA_Extensions
-\brief Calls starpu_cublas_report_error(), passing the current
+Calls starpu_cublas_report_error(), passing the current
 function, file and line position.
 
 */

doc/doxygen/chapters/api/data_interfaces.doxy

@@ -48,7 +48,9 @@ Unpack the data handle from the contiguous buffer at the address ptr
 of size count
 
 \struct starpu_data_copy_methods
-\brief Defines the per-interface methods. If the any_to_any method is
+\brief Defines the per-interface methods.
+
+If the any_to_any method is
 provided, it will be used by default if no more specific method is
 provided. It can still be useful to provide more specific method in
 case of e.g. available particular CUDA or OpenCL support.
@@ -153,7 +155,7 @@ matrices.
 
 \fn void starpu_void_data_register(starpu_data_handle_t *handle)
 \ingroup Data_Interfaces
-\brief Register a void interface. There is no data really associated
+Register a void interface. There is no data really associated
 to that interface, but it may be used as a synchronization mechanism.
 It also permits to express an abstract piece of data that is managed
 by the application internally: this makes it possible to forbid the
@@ -162,7 +164,7 @@ in read-write concurrently.
 
 \fn void starpu_variable_data_register(starpu_data_handle_t *handle, unsigned home_node, uintptr_t ptr, size_t size)
 \ingroup Data_Interfaces
-\brief Register the \p size byte element pointed to by \p ptr, which is
+Register the \p size byte element pointed to by \p ptr, which is
 typically a scalar, and initialize \p handle to represent this data item.
 
 Here an example of how to use the function.
@@ -174,7 +176,7 @@ starpu_variable_data_register(&var_handle, 0, (uintptr_t)&var, sizeof(var));
 
 \fn void starpu_vector_data_register(starpu_data_handle_t *handle, unsigned home_node, uintptr_t ptr, uint32_t nx, size_t elemsize)
 \ingroup Data_Interfaces
-\brief Register the \p nx elemsize-byte elements pointed to by \p ptr and initialize \p handle to represent it.
+Register the \p nx elemsize-byte elements pointed to by \p ptr and initialize \p handle to represent it.
 
 Here an example of how to use the function.
 \code{.c}
@@ -185,7 +187,7 @@ starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX, sizeof(vec
 
 \fn void starpu_matrix_data_register(starpu_data_handle_t *handle, unsigned home_node, uintptr_t ptr, uint32_t ld, uint32_t nx, uint32_t ny, size_t elemsize)
 \ingroup Data_Interfaces
-\brief Register the \p nx x \p  ny 2D matrix of \p elemsize-byte elements pointed
+Register the \p nx x \p  ny 2D matrix of \p elemsize-byte elements pointed
 by \p ptr and initialize \p handle to represent it. \p ld specifies the number
 of elements between rows. a value greater than \p nx adds padding, which
 can be useful for alignment purposes.
@@ -200,7 +202,7 @@ starpu_matrix_data_register(&matrix_handle, 0, (uintptr_t)matrix, width, width,
 
 \fn void starpu_block_data_register(starpu_data_handle_t *handle, unsigned home_node, uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx, uint32_t ny, uint32_t nz, size_t elemsize)
 \ingroup Data_Interfaces
-\brief Register the \p nx x \p ny x \p nz 3D matrix of \p elemsize byte elements
+Register the \p nx x \p ny x \p nz 3D matrix of \p elemsize byte elements
 pointed by \p ptr and initialize \p handle to represent it. Again, \p ldy and
 \p ldz specify the number of elements between rows and between z planes.
 
@@ -214,7 +216,7 @@ starpu_block_data_register(&block_handle, 0, (uintptr_t)block, nx, nx*ny, nx, ny
 
 \fn void starpu_bcsr_data_register(starpu_data_handle_t *handle, unsigned 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)
 \ingroup Data_Interfaces
-\brief This variant of starpu_data_register() uses the BCSR (Blocked
+This variant of starpu_data_register() uses the BCSR (Blocked
 Compressed Sparse Row Representation) sparse matrix interface.
 Register the sparse matrix made of \p nnz non-zero blocks of elements of
 size \p elemsize stored in \p nzval and initializes \p handle to represent it.
@@ -226,18 +228,18 @@ blocks), \p colind[i] is the block-column index for block i in \p nzval,
 
 \fn void starpu_csr_data_register(starpu_data_handle_t *handle, unsigned home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize)
 \ingroup Data_Interfaces
-\brief This variant of starpu_data_register() uses the CSR (Compressed
+This variant of starpu_data_register() uses the CSR (Compressed
 Sparse Row Representation) sparse matrix interface. TODO
 
 \fn void starpu_coo_data_register(starpu_data_handle_t *handleptr, unsigned home_node, uint32_t nx, uint32_t ny, uint32_t n_values, uint32_t *columns, uint32_t *rows, uintptr_t values, size_t elemsize);
 \ingroup Data_Interfaces
-\brief Register the \p nx x \p ny 2D matrix given in the COO format, using the
+Register the \p nx x \p ny 2D matrix given in the COO format, using the
 \p columns, \p rows, \p values arrays, which must have \p n_values elements of
 size \p elemsize. Initialize \p handleptr.
 
 \fn void *starpu_data_get_interface_on_node(starpu_data_handle_t handle, unsigned memory_node)
 \ingroup Data_Interfaces
-\brief Return the interface associated with \p handle on \p memory_node.
+Return the interface associated with \p handle on \p memory_node.
 
 @name Accessing Data Interfaces
 \ingroup Data_Interfaces
@@ -249,27 +251,27 @@ Vector_Scaling_Using_StarPU_API).
 
 \fn void *starpu_data_handle_to_pointer(starpu_data_handle_t handle, unsigned node)
 \ingroup Data_Interfaces
-\brief Return the pointer associated with \p handle on node \p node or <c>NULL</c>
+Return the pointer associated with \p handle on node \p node or <c>NULL</c>
 if handle’s interface does not support this operation or data for this
 \p handle is not allocated on that \p node.
 
 \fn void *starpu_data_get_local_ptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the local pointer associated with \p handle or <c>NULL</c> if
+Return the local pointer associated with \p handle or <c>NULL</c> if
 \p handle’s interface does not have data allocated locally 
 
 \fn enum starpu_data_interface_id starpu_data_get_interface_id(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the unique identifier of the interface associated with
+Return the unique identifier of the interface associated with
 the given \p handle.
 
 \fn size_t starpu_data_get_size(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the data associated with \p handle.
+Return the size of the data associated with \p handle.
 
 \fn int starpu_data_pack(starpu_data_handle_t handle, void **ptr, starpu_ssize_t *count)
 \ingroup Data_Interfaces
-\brief Execute the packing operation of the interface of the data
+Execute the packing operation of the interface of the data
 registered at \p handle (see starpu_data_interface_ops). This
 packing operation must allocate a buffer large enough at \p ptr and copy
 into the newly allocated buffer the data associated to \p handle. \p count
@@ -280,7 +282,7 @@ value -1 indicates the size is yet unknown.
 
 \fn int starpu_data_unpack(starpu_data_handle_t handle, void *ptr, size_t count)
 \ingroup Data_Interfaces
-\brief Unpack in handle the data located at \p ptr of size \p count as
+Unpack in handle the data located at \p ptr of size \p count as
 described by the interface of the data. The interface registered at
 \p handle must define a unpacking operation (see
 starpu_data_interface_ops). The memory at the address \p ptr is freed
@@ -289,467 +291,606 @@ after calling the data unpacking operation.
 @name Accessing Variable Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_variable_interface
+\brief Variable interface for a single data (not a vector, a matrix, a list, ...)
+\ingroup Data_Interfaces
+\var starpu_variable_interface::id
+Identifier of the interface
+\var starpu_variable_interface::ptr
+local pointer of the variable
+\var starpu_variable_interface::dev_handle
+device handle of the variable.
+\var starpu_variable_interface::offset
+offset in the variable
+\var starpu_variable_interface::elemsize
+size of the variable
+
 \fn size_t starpu_variable_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the variable designated by \p handle.
+Return the size of the variable designated by \p handle.
 
 \fn uintptr_t starpu_variable_get_local_ptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a pointer to the variable designated by \p handle.
+Return a pointer to the variable designated by \p handle.
 
 \def STARPU_VARIABLE_GET_PTR(interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the variable designated by \p interface.
+Return a pointer to the variable designated by \p interface.
 
 \def STARPU_VARIABLE_GET_ELEMSIZE(interface)
 \ingroup Data_Interfaces
-\brief Return the size of the variable designated by \p interface.
+Return the size of the variable designated by \p interface.
 
 \def STARPU_VARIABLE_GET_DEV_HANDLE(interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the variable designated by
+Return a device handle for the variable designated by
 \p interface, to be used on OpenCL. The offset documented below has to be
 used in addition to this.
 
 \def STARPU_VARIABLE_GET_OFFSET()
 \ingroup Data_Interfaces
-\brief Return the offset in the variable designated by \p interface, to
+Return the offset in the variable designated by \p interface, to
 be used with the device handle.
 
 @name Accessing Vector Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_vector_interface
+\brief Vector interface
+\ingroup Data_Interfaces
+\var starpu_vector_interface::id
+Identifier of the interface
+\var starpu_vector_interface::ptr
+local pointer of the vector
+\var starpu_vector_interface::dev_handle
+device handle of the vector.
+\var starpu_vector_interface::offset
+offset in the vector
+\var starpu_vector_interface::nx
+number of elements on the x-axis of the vector
+\var starpu_vector_interface::elemsize
+size of the elements of the vector
+
 \fn uint32_t starpu_vector_get_nx(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements registered into the array designated by \p handle.
+Return the number of elements registered into the array designated by \p handle.
 
 \fn size_t starpu_vector_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of each element of the array designated by \p handle.
+Return the size of each element of the array designated by \p handle.
 
 \fn uintptr_t starpu_vector_get_local_ptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the local pointer associated with \p handle.
+Return the local pointer associated with \p handle.
 
 \def STARPU_VECTOR_GET_PTR(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the array designated by \p interface, valid on
+Return a pointer to the array designated by \p interface, valid on
 CPUs and CUDA only. For OpenCL, the device handle and offset need to
 be used instead.
 
 \def STARPU_VECTOR_GET_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the array designated by \p interface,
+Return a device handle for the array designated by \p interface,
 to be used on OpenCL. the offset documented below has to be used in
 addition to this.
 
 \def STARPU_VECTOR_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the array designated by \p interface, to be
+Return the offset in the array designated by \p interface, to be
 used with the device handle.
 
 \def STARPU_VECTOR_GET_NX(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements registered into the array
+Return the number of elements registered into the array
 designated by \p interface.
 
 \def STARPU_VECTOR_GET_ELEMSIZE(void *interface)
 \ingroup Data_Interfaces
-\brief Return the size of each element of the array designated by
+Return the size of each element of the array designated by
 \p interface.
 
 @name Accessing Matrix Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_matrix_interface
+\brief Matrix interface for dense matrices
+\ingroup Data_Interfaces
+\var starpu_matrix_interface::id
+Identifier of the interface
+\var starpu_matrix_interface::ptr
+local pointer of the matrix
+\var starpu_matrix_interface::dev_handle
+device handle of the matrix.
+\var starpu_matrix_interface::offset
+offset in the matrix
+\var starpu_matrix_interface::nx
+number of elements on the x-axis of the matrix
+\var starpu_matrix_interface::ny
+number of elements on the y-axis of the matrix
+\var starpu_matrix_interface::ld
+number of elements between each row of the matrix. Maybe be equal to
+starpu_matrix_interface::nx when there is no padding.
+\var starpu_matrix_interface::elemsize
+size of the elements of the matrix
+
 \fn uint32_t starpu_matrix_get_nx(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the x-axis of the matrix
+Return the number of elements on the x-axis of the matrix
 designated by \p handle.
 
 \fn uint32_t starpu_matrix_get_ny(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the y-axis of the matrix
+Return the number of elements on the y-axis of the matrix
 designated by \p handle.
 
 \fn uint32_t starpu_matrix_get_local_ld(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each row of the matrix
+Return the number of elements between each row of the matrix
 designated by \p handle. Maybe be equal to nx when there is no padding.
 
 \fn uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the local pointer associated with \p handle.
+Return the local pointer associated with \p handle.
 
 \fn size_t starpu_matrix_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the elements registered into the matrix
+Return the size of the elements registered into the matrix
 designated by \p handle.
 
 \def STARPU_MATRIX_GET_PTR(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the matrix designated by \p interface, valid
+Return a pointer to the matrix designated by \p interface, valid
 on CPUs and CUDA devices only. For OpenCL devices, the device handle
 and offset need to be used instead.
 
 \def STARPU_MATRIX_GET_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the matrix designated by \p interface,
+Return a device handle for the matrix designated by \p interface,
 to be used on OpenCL. The offset documented below has to be used in
 addition to this.
 
 \def STARPU_MATRIX_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the matrix designated by \p interface, to be
+Return the offset in the matrix designated by \p interface, to be
 used with the device handle.
 
 \def STARPU_MATRIX_GET_NX(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the x-axis of the matrix
+Return the number of elements on the x-axis of the matrix
 designated by \p interface.
 
 \def STARPU_MATRIX_GET_NY(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the y-axis of the matrix
+Return the number of elements on the y-axis of the matrix
 designated by \p interface.
 
 \def STARPU_MATRIX_GET_LD(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each row of the matrix
+Return the number of elements between each row of the matrix
 designated by \p interface. May be equal to nx when there is no padding.
 
 \def STARPU_MATRIX_GET_ELEMSIZE(void *interface)
 \ingroup Data_Interfaces
-\brief Return the size of the elements registered into the matrix
+Return the size of the elements registered into the matrix
 designated by \p interface.
 
 @name Accessing Block Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_block_interface
+\brief Block interface for 3D dense blocks
+\ingroup Data_Interfaces
+\struct starpu_block_interface::id
+identifier of the interface
+\var starpu_block_interface::ptr
+local pointer of the block
+\var starpu_block_interface::dev_handle
+device handle of the block.
+\var starpu_block_interface::offset
+offset in the block.
+\var starpu_block_interface::nx
+number of elements on the x-axis of the block.
+\var starpu_block_interface::ny
+number of elements on the y-axis of the block.
+\var starpu_block_interface::nz
+number of elements on the z-axis of the block.
+\var starpu_block_interface::ldy
+number of elements between two lines
+\var starpu_block_interface::ldz
+number of elements between two planes
+\var starpu_block_interface::elemsize
+size of the elements of the block.
+
 \fn uint32_t starpu_block_get_nx(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the x-axis of the block
+Return the number of elements on the x-axis of the block
 designated by \p handle.
 
 \fn uint32_t starpu_block_get_ny(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the y-axis of the block
+Return the number of elements on the y-axis of the block
 designated by \p handle.
 
 \fn uint32_t starpu_block_get_nz(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the z-axis of the block
+Return the number of elements on the z-axis of the block
 designated by \p handle.
 
 \fn uint32_t starpu_block_get_local_ldy(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each row of the block
+Return the number of elements between each row of the block
 designated by \p handle, in the format of the current memory node.
 
 \fn uint32_t starpu_block_get_local_ldz(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each z plane of the block
+Return the number of elements between each z plane of the block
 designated by \p handle, in the format of the current memory node.
 
 \fn uintptr_t starpu_block_get_local_ptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the local pointer associated with \p handle.
+Return the local pointer associated with \p handle.
 
 \fn size_t starpu_block_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the elements of the block designated by
+Return the size of the elements of the block designated by
 \p handle.
 
 \def STARPU_BLOCK_GET_PTR(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the block designated by \p interface.
+Return a pointer to the block designated by \p interface.
 
 \def STARPU_BLOCK_GET_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the block designated by \p interface,
+Return a device handle for the block designated by \p interface,
 to be used on OpenCL. The offset document below has to be used in
 addition to this.
 
 \def STARPU_BLOCK_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the block designated by \p interface, to be
+Return the offset in the block designated by \p interface, to be
 used with the device handle.
 
 \def STARPU_BLOCK_GET_NX(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the x-axis of the block
+Return the number of elements on the x-axis of the block
 designated by \p interface.
 
 \def STARPU_BLOCK_GET_NY(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the y-axis of the block
+Return the number of elements on the y-axis of the block
 designated by \p interface.
 
 \def STARPU_BLOCK_GET_NZ(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the z-axis of the block
+Return the number of elements on the z-axis of the block
 designated by \p interface.
 
 \def STARPU_BLOCK_GET_LDY(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each row of the block
+Return the number of elements between each row of the block
 designated by \p interface. May be equal to nx when there is no padding.
 
 \def STARPU_BLOCK_GET_LDZ(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements between each z plane of the block
+Return the number of elements between each z plane of the block
 designated by \p interface. May be equal to nx*ny when there is no
 padding.
 
 \def STARPU_BLOCK_GET_ELEMSIZE(void *interface)
 \ingroup Data_Interfaces
-\brief Return the size of the elements of the block designated by
+Return the size of the elements of the block designated by
 \p interface.
 
 @name Accessing BCSR Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_bcsr_interface
+\brief BCSR interface for sparse matrices (blocked compressed sparse
+row representation)
+\ingroup Data_Interfaces
+\var starpu_bcsr_interface::id
+Identifier of the interface
+\var starpu_bcsr_interface::nnz
+number of non-zero BLOCKS
+\var starpu_bcsr_interface::nrow
+number of rows (in terms of BLOCKS)
+\var starpu_bcsr_interface::nzval
+non-zero values
+\var starpu_bcsr_interface::colind
+position of non-zero entried on the row
+\var starpu_bcsr_interface::rowptr
+index (in nzval) of the first entry of the row
+\var starpu_bcsr_interface::firstentry
+k for k-based indexing (0 or 1 usually). Also useful when partitionning the matrix.
+\var starpu_bcsr_interface::r
+size of the blocks
+\var starpu_bcsr_interface::c
+size of the blocks
+\var starpu_bcsr_interface::elemsize;
+size of the elements of the matrix
+
 \fn uint32_t starpu_bcsr_get_nnz(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of non-zero elements in the matrix designated
+Return the number of non-zero elements in the matrix designated
 by \p handle.
 
 \fn uint32_t starpu_bcsr_get_nrow(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of rows (in terms of blocks of size r*c) in
+Return the number of rows (in terms of blocks of size r*c) in
 the matrix designated by \p handle.
 
 \fn uint32_t starpu_bcsr_get_firstentry(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the index at which all arrays (the column indexes, the
+Return the index at which all arrays (the column indexes, the
 row pointers...) of the matrix desginated by \p handle.
 
 \fn uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a pointer to the non-zero values of the matrix
+Return a pointer to the non-zero values of the matrix
 designated by \p handle.
 
 \fn uint32_t * starpu_bcsr_get_local_colind(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a pointer to the column index, which holds the positions
+Return a pointer to the column index, which holds the positions
 of the non-zero entries in the matrix designated by \p handle.
 
 \fn uint32_t * starpu_bcsr_get_local_rowptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the row pointer array of the matrix designated by
+Return the row pointer array of the matrix designated by
 \p handle.
 
 \fn uint32_t starpu_bcsr_get_r(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of rows in a block.
+Return the number of rows in a block.
 
 \fn uint32_t starpu_bcsr_get_c(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the numberof columns in a block.
+Return the numberof columns in a block.
 
 \fn size_t starpu_bcsr_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the elements in the matrix designated by
+Return the size of the elements in the matrix designated by
 \p handle.
 
 \def STARPU_BCSR_GET_NNZ(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of non-zero values in the matrix designated
+Return the number of non-zero values in the matrix designated
 by \p interface.
 
 \def STARPU_BCSR_GET_NZVAL(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the non-zero values of the matrix
+Return a pointer to the non-zero values of the matrix
 designated by \p interface.
 
 \def STARPU_BCSR_GET_NZVAL_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the array of non-zero values in the
+Return a device handle for the array of non-zero values in the
 matrix designated by \p interface. The offset documented below has to be
 used in addition to this.
 
 \def STARPU_BCSR_GET_COLIND(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the column index of the matrix designated
+Return a pointer to the column index of the matrix designated
 by \p interface.
 
 \def STARPU_BCSR_GET_COLIND_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the column index of the matrix
+Return a device handle for the column index of the matrix
 designated by \p interface. The offset documented below has to be used in
 addition to this.
 
 \def STARPU_BCSR_GET_ROWPTR(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the row pointer array of the matrix
+Return a pointer to the row pointer array of the matrix
 designated by \p interface.
 
 \def STARPU_CSR_GET_ROWPTR_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the row pointer array of the matrix
+Return a device handle for the row pointer array of the matrix
 designated by \p interface. The offset documented below has to be used in
 addition to this.
 
 \def STARPU_BCSR_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the arrays (coling, rowptr, nzval) of the
+Return the offset in the arrays (coling, rowptr, nzval) of the
 matrix designated by \p interface, to be used with the device handles.
 
-
 @name Accessing CSR Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_csr_interface
+\brief CSR interface for sparse matrices (compressed sparse row representation)
+\ingroup Data_Interfaces
+\var starpu_csr_interface::id
+Identifier of the interface
+\var starpu_csr_interface::nnz
+number of non-zero entries
+\var starpu_csr_interface::nrow
+number of rows
+\var starpu_csr_interface::nzval
+non-zero values
+\var starpu_csr_interface::colind
+position of non-zero entries on the row
+\var starpu_csr_interface::rowptr
+index (in nzval) of the first entry of the row
+\var starpu_csr_interface::firstentry
+k for k-based indexing (0 or 1 usually). also useful when partitionning the matrix.
+\var starpu_csr_interface::elemsize
+size of the elements of the matrix
+
 \fn uint32_t starpu_csr_get_nnz(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the number of non-zero values in the matrix designated
+Return the number of non-zero values in the matrix designated
 by \p handle.
 
 \fn uint32_t starpu_csr_get_nrow(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the row pointer array of the matrix
+Return the size of the row pointer array of the matrix
 designated by \p handle.
 
 \fn uint32_t starpu_csr_get_firstentry(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the index at which all arrays (the column indexes, the
+Return the index at which all arrays (the column indexes, the
 row pointers...) of the matrix designated by \p handle.
 
 \fn uintptr_t starpu_csr_get_local_nzval(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a local pointer to the non-zero values of the matrix
+Return a local pointer to the non-zero values of the matrix
 designated by \p handle.
 
 \fn uint32_t * starpu_csr_get_local_colind(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a local pointer to the column index of the matrix
+Return a local pointer to the column index of the matrix
 designated by \p handle.
 
 \fn uint32_t * starpu_csr_get_local_rowptr(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return a local pointer to the row pointer array of the matrix
+Return a local pointer to the row pointer array of the matrix
 designated by \p handle.
 
 \fn size_t starpu_csr_get_elemsize(starpu_data_handle_t handle)
 \ingroup Data_Interfaces
-\brief Return the size of the elements registered into the matrix
+Return the size of the elements registered into the matrix
 designated by \p handle.
 
 \def STARPU_CSR_GET_NNZ(void *interface)
 \ingroup Data_Interfaces
-\brief Return the number of non-zero values in the matrix designated
+Return the number of non-zero values in the matrix designated
 by \p interface.
 
 \def STARPU_CSR_GET_NROW(void *interface)
 \ingroup Data_Interfaces
-\brief Return the size of the row pointer array of the matrix
+Return the size of the row pointer array of the matrix
 designated by \p interface.
 
 \def STARPU_CSR_GET_NZVAL(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the non-zero values of the matrix
+Return a pointer to the non-zero values of the matrix
 designated by \p interface.
 
 \def STARPU_CSR_GET_NZVAL_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the array of non-zero values in the
+Return a device handle for the array of non-zero values in the
 matrix designated by \p interface. The offset documented below has to be
 used in addition to this.
 
 \def STARPU_CSR_GET_COLIND(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the column index of the matrix designated
+Return a pointer to the column index of the matrix designated
 by \p interface.
 
 \def STARPU_CSR_GET_COLIND_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the column index of the matrix
+Return a device handle for the column index of the matrix
 designated by \p interface. The offset documented below has to be used in
 addition to this.
 
 \def STARPU_CSR_GET_ROWPTR(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the row pointer array of the matrix
+Return a pointer to the row pointer array of the matrix
 designated by \p interface.
 
 \def STARPU_CSR_GET_ROWPTR_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the row pointer array of the matrix
+Return a device handle for the row pointer array of the matrix
 designated by \p interface. The offset documented below has to be used in
 addition to this.
 
 \def STARPU_CSR_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the arrays (colind, rowptr, nzval) of the
+Return the offset in the arrays (colind, rowptr, nzval) of the
 matrix designated by \p interface, to be used with the device handles.
 
 \def STARPU_CSR_GET_FIRSTENTRY(void *interface)
 \ingroup Data_Interfaces
-\brief Return the index at which all arrays (the column indexes, the
+Return the index at which all arrays (the column indexes, the
 row pointers...) of the \p interface start.
 
 \def STARPU_CSR_GET_ELEMSIZE(void *interface)
 \ingroup Data_Interfaces
-\brief Return the size of the elements registered into the matrix
+Return the size of the elements registered into the matrix
 designated by \p interface.
 
 @name Accessing COO Data Interfaces
 \ingroup Data_Interfaces
 
+\struct starpu_coo_interface
+\brief COO Matrices
+\ingroup Data_Interfaces
+\var starpu_coo_interface::id
+identifier of the interface
+\var starpu_coo_interface::columns
+column array of the matrix
+\var starpu_coo_interface::rows
+row array of the matrix
+\var starpu_coo_interface::values
+values of the matrix
+\var starpu_coo_interface::nx
+number of elements on the x-axis of the matrix
+\var starpu_coo_interface::ny
+number of elements on the y-axis of the matrix
+\var starpu_coo_interface::n_values
+number of values registered in the matrix
+\var starpu_coo_interface::elemsize
+size of the elements of the matrix
+
 \def STARPU_COO_GET_COLUMNS(void *interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the column array of the matrix designated
+Return a pointer to the column array of the matrix designated
 by \p interface.
 
 \def STARPU_COO_GET_COLUMNS_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the column array of the matrix
+Return a device handle for the column array of the matrix
 designated by \p interface, to be used on OpenCL. The offset documented
 below has to be used in addition to this.
 
 \def STARPU_COO_GET_ROWS(interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the rows array of the matrix designated by
+Return a pointer to the rows array of the matrix designated by
 \p interface.
 
 \def STARPU_COO_GET_ROWS_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the row array of the matrix
+Return a device handle for the row array of the matrix
 designated by \p interface, to be used on OpenCL. The offset documented
 below has to be used in addition to this.
 
 \def STARPU_COO_GET_VALUES(interface)
 \ingroup Data_Interfaces
-\brief Return a pointer to the values array of the matrix designated
+Return a pointer to the values array of the matrix designated
 by \p interface.
 
 \def STARPU_COO_GET_VALUES_DEV_HANDLE(void *interface)
 \ingroup Data_Interfaces
-\brief Return a device handle for the value array of the matrix
+Return a device handle for the value array of the matrix
 designated by \p interface, to be used on OpenCL. The offset documented
 below has to be used in addition to this.
 
-\def STARPU_COO_GET_OFFSET(void *itnerface)
+\def STARPU_COO_GET_OFFSET(void *interface)
 \ingroup Data_Interfaces
-\brief Return the offset in the arrays of the COO matrix designated by
+Return the offset in the arrays of the COO matrix designated by
 \p interface.
 
 \def STARPU_COO_GET_NX(interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the x-axis of the matrix
+Return the number of elements on the x-axis of the matrix
 designated by \p interface.
 
 \def STARPU_COO_GET_NY(interface)
 \ingroup Data_Interfaces
-\brief Return the number of elements on the y-axis of the matrix
+Return the number of elements on the y-axis of the matrix
 designated by \p interface.
 
 \def STARPU_COO_GET_NVALUES(interface)
 \ingroup Data_Interfaces
-\brief Return the number of values registered in the matrix designated
+Return the number of values registered in the matrix designated
 by \p interface.
 
 \def STARPU_COO_GET_ELEMSIZE(interface)
 \ingroup Data_Interfaces
-\brief Return the size of the elements registered into the matrix
+Return the size of the elements registered into the matrix
 designated by \p interface.
 
 @name Defining Interface
@@ -760,17 +901,17 @@ Defining_a_New_Data_Interface.
 
 \fn uintptr_t starpu_malloc_on_node(unsigned dst_node, size_t size)
 \ingroup Data_Interfaces
-\brief Allocate \p size bytes on node \p dst_node. This returns 0 if
+Allocate \p size bytes on node \p dst_node. This returns 0 if
 allocation failed, the allocation method should then return <c>-ENOMEM</c> as
 allocated size.
 
 \fn void starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
 \ingroup Data_Interfaces
-\brief Free \p addr of \p size bytes on node \p dst_node.
+Free \p addr of \p size bytes on node \p dst_node.
 
 \fn int starpu_interface_copy(uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, void *async_data)
 \ingroup Data_Interfaces
-\brief Copy \p size bytes from byte offset \p src_offset of \p src on \p src_node
+Copy \p size bytes from byte offset \p src_offset of \p src on \p src_node
 to byte offset \p dst_offset of \p dst on \p dst_node. This is to be used in
 the any_to_any() copy method, which is provided with the async_data to
 be passed to starpu_interface_copy(). this returns <c>-EAGAIN</c> if the
@@ -778,28 +919,28 @@ transfer is still ongoing, or 0 if the transfer is already completed.
 
 \fn uint32_t starpu_hash_crc32c_be_n(const void *input, size_t n, uint32_t inputcrc)
 \ingroup Data_Interfaces
-\brief Compute the CRC of a byte buffer seeded by the \p inputcrc
+Compute the CRC of a byte buffer seeded by the \p inputcrc
 <em>current state</em>. The return value should be considered as the new
 <em>current state</em> for future CRC computation. This is used for computing
 data size footprint.
 
 \fn uint32_t starpu_hash_crc32c_be(uint32_t input, uint32_t inputcrc)
 \ingroup Data_Interfaces
-\brief Compute the CRC of a 32bit number seeded by the \p inputcrc
+Compute the CRC of a 32bit number seeded by the \p inputcrc
 <em>current state</em>. The return value should be considered as the new
 <em>current state</em> for future CRC computation. This is used for computing
 data size footprint.
 
 \fn uint32_t starpu_hash_crc32c_string(const char *str, uint32_t inputcrc)
 \ingroup Data_Interfaces
-\brief Compute the CRC of a string seeded by the \p inputcrc <em>current
+Compute the CRC of a string seeded by the \p inputcrc <em>current
 state</em>. The return value should be considered as the new <em>current
 state</em> for future CRC computation. This is used for computing data
 size footprint.
 
 \fn int starpu_data_interface_get_next_id(void)
 \ingroup Data_Interfaces
-\brief Return the next available id for a newly created data interface
+Return the next available id for a newly created data interface
 (\ref Defining_a_New_Data_Interface).
 
 */

doc/doxygen/chapters/api/data_management.doxy

@@ -15,7 +15,7 @@ if required.
 
 \typedef starpu_data_handle_t
 \ingroup Data_Management
-\brief StarPU uses ::starpu_data_handle_t as an opaque handle to
+StarPU uses ::starpu_data_handle_t as an opaque handle to
 manage a piece of data. Once a piece of data has been registered to
 StarPU, it is associated to a starpu_data_handle_t which keeps track
 of the state of the piece of data over the entire machine, so that we
@@ -54,7 +54,7 @@ a piece of data).
 
 \fn void starpu_data_register(starpu_data_handle_t *handleptr, unsigned home_node, void *data_interface, struct starpu_data_interface_ops *ops)
 \ingroup Data_Management
-\brief Register a piece of data into the handle located at the
+Register a piece of data into the handle located at the
 \p handleptr address. The \p data_interface buffer contains the initial
 description of the data in the \p home_node. The \p ops argument is a
 pointer to a structure describing the different methods used to
@@ -71,12 +71,12 @@ starpu_matrix_data_register()).
 
 \fn void starpu_data_register_same(starpu_data_handle_t *handledst, starpu_data_handle_t handlesrc)
 \ingroup Data_Management
-\brief Register a new piece of data into the handle \p handledst with the
+Register a new piece of data into the handle \p handledst with the
 same interface as the handle \p handlesrc.
 
 \fn void starpu_data_unregister(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief This function unregisters a data handle from StarPU. If the
+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 is put back into the home node in the buffer that was
@@ -87,30 +87,30 @@ the function starpu_data_unregister_no_coherency() instead.
 
 \fn void starpu_data_unregister_no_coherency(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief This is the same as starpu_data_unregister(), except that
+This is the same as starpu_data_unregister(), except that
 StarPU does not put back a valid copy into the home node, in the
 buffer that was initially registered.
 
 \fn void starpu_data_unregister_submit(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief Destroy the data handle once it is not needed anymore by any
+Destroy the data handle once it is not needed anymore by any
 submitted task. No coherency is assumed.
 
 \fn void starpu_data_invalidate(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief Destroy all replicates of the data handle immediately. After
+Destroy all replicates of the data handle immediately. 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.
 
 \fn void starpu_data_invalidate_submit(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief Submits invalidation of the data handle after completion of
+Submits invalidation of the data handle after completion of
 previously submitted tasks.
 
 \fn void starpu_data_set_wt_mask(starpu_data_handle_t handle, uint32_t wt_mask)
 \ingroup Data_Management
-\brief This function sets the write-through mask of a given data (and
+This function sets the write-through mask of a given data (and
 its children), i.e. a bitmask of nodes where the data should be always
 replicated after modification. It also prevents the data from being
 evicted from these nodes when memory gets scarse. When the data is
@@ -120,7 +120,7 @@ will commit their changes in main memory (node 0).
 
 \fn int starpu_data_prefetch_on_node(starpu_data_handle_t handle, unsigned node, unsigned async)
 \ingroup Data_Management
-\brief Issue a prefetch request for a given data to a given node, i.e.
+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 \p async parameter is 0, the call will
 block until the transfer is achieved, else the call will return as
@@ -129,25 +129,25 @@ task completion).
 
 \fn starpu_data_handle_t starpu_data_lookup(const void *ptr)
 \ingroup Data_Management
-\brief Return the handle corresponding to the data pointed to by the \p ptr host pointer.
+Return the handle corresponding to the data pointed to by the \p ptr host pointer.
 
 \fn int starpu_data_request_allocation(starpu_data_handle_t handle, unsigned node)
 \ingroup Data_Management
-\brief Explicitly ask StarPU to allocate room for a piece of data on
+Explicitly ask StarPU to allocate room for a piece of data on
 the specified memory node.
 
 \fn void starpu_data_query_status(starpu_data_handle_t handle, int memory_node, int *is_allocated, int *is_valid, int *is_requested)
 \ingroup Data_Management
-\brief Query the status of \p handle on the specified \p memory_node.
+Query the status of \p handle on the specified \p memory_node.
 
 \fn void starpu_data_advise_as_important(starpu_data_handle_t handle, unsigned is_important)
 \ingroup Data_Management
-\brief This function allows to specify that a piece of data can be
+This function allows to specify that a piece of data can be
 discarded without impacting the application.
 
 \fn void starpu_data_set_reduction_methods(starpu_data_handle_t handle, struct starpu_codelet *redux_cl, struct starpu_codelet *init_cl)
 \ingroup Data_Management
-\brief This sets the codelets to be used for \p handle when it is
+This sets the codelets to be used for \p handle when it is
 accessed in STARPU_REDUX mode. Per-worker buffers will be initialized with
 the \p init_cl codelet, and reduction between per-worker buffers will be
 done with the \p redux_cl codelet.
@@ -157,7 +157,7 @@ done with the \p redux_cl codelet.
 
 \fn int starpu_data_acquire(starpu_data_handle_t handle, enum starpu_data_access_mode mode)
 \ingroup Data_Management
-\brief The application must call this function prior to accessing
+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 originally registered, and that all
@@ -175,7 +175,7 @@ successful completion, this function returns 0.
 
 \fn int starpu_data_acquire_cb(starpu_data_handle_t handle, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg)
 \ingroup Data_Management
-\brief Asynchronous equivalent of starpu_data_acquire(). When the data
+Asynchronous equivalent of starpu_data_acquire(). When the data
 specified in \p handle is available in the appropriate access
 mode, the \p callback function is executed. The application may access
 the requested data during the execution of this \p callback. The \p callback
@@ -188,18 +188,18 @@ completion, this function returns 0.
 
 \fn int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum starpu_data_access_mode mode)
 \ingroup Data_Management
-\brief This is the same as starpu_data_acquire(), except that the data
+This is the same as starpu_data_acquire(), except that the data
 will be available on the given memory node instead of main memory.
 
 \fn int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, unsigned node, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg)
 \ingroup Data_Management
-\brief This is the same as starpu_data_acquire_cb(), except that the
+This is the same as starpu_data_acquire_cb(), except that the
 data will be available on the given memory node instead of main
 memory.
 
 \def STARPU_DATA_ACQUIRE_CB(starpu_data_handle_t handle, enum starpu_data_access_mode mode, code)
 \ingroup Data_Management
-\brief STARPU_DATA_ACQUIRE_CB() is the same as starpu_data_acquire_cb(),
+STARPU_DATA_ACQUIRE_CB() is the same as starpu_data_acquire_cb(),
 except that the code to be executed in a callback is directly provided
 as a macro parameter, and the data \p handle is automatically released
 after it. This permits to easily execute code which depends on the
@@ -208,13 +208,13 @@ called from task callbacks.
 
 \fn void starpu_data_release(starpu_data_handle_t handle)
 \ingroup Data_Management
-\brief This function releases the piece of data acquired by the
+This function releases the piece of data acquired by the
 application either by starpu_data_acquire() or by
 starpu_data_acquire_cb().
 
 \fn void starpu_data_release_on_node(starpu_data_handle_t handle, unsigned node)
 \ingroup Data_Management
-\brief This is the same as starpu_data_release(), except that the data
+This is the same as starpu_data_release(), except that the data
 will be available on the given memory \p node instead of main memory.
 
 */

doc/doxygen/chapters/api/data_partition.doxy

@@ -35,7 +35,7 @@ function, such as the sizes of the different parts.
 
 \fn void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_data_filter *f)
 \ingroup Data_Partition
-\brief This requests partitioning one StarPU data initial_handle into
+This requests partitioning one StarPU data initial_handle into
 several subdata according to the filter \p f.
 
 Here an example of how to use the function.
@@ -51,7 +51,7 @@ starpu_data_partition(A_handle, &f);
 
 \fn void starpu_data_unpartition(starpu_data_handle_t root_data, unsigned gathering_node)
 \ingroup Data_Partition
-\brief This unapplies one filter, thus unpartitioning the data. The
+This unapplies one filter, thus unpartitioning the data. The
 pieces of data are collected back into one big piece in the
 \p gathering_node (usually 0). Tasks working on the partitioned data must
 be already finished when calling starpu_data_unpartition().
@@ -63,16 +63,16 @@ starpu_data_unpartition(A_handle, 0);
 
 \fn int starpu_data_get_nb_children(starpu_data_handle_t handle)
 \ingroup Data_Partition
-\brief This function returns the number of children.
+This function returns the number of children.
 
 \fn starpu_data_handle_t starpu_data_get_child(starpu_data_handle_t handle, unsigned i)
 \ingroup Data_Partition
-\brief Return the ith child of the given \p handle, which must have been
+Return the ith child of the given \p handle, which must have been
 partitionned beforehand.
 
 \fn starpu_data_handle_t starpu_data_get_sub_data (starpu_data_handle_t root_data, unsigned depth, ... )
 \ingroup Data_Partition
-\brief After partitioning a StarPU data by applying a filter,
+After partitioning a StarPU data by applying a filter,
 starpu_data_get_sub_data() can be used to get handles for each of the
 data portions. \p root_data is the parent data that was partitioned.
 \p depth is the number of filters to traverse (in case several filters
@@ -87,18 +87,18 @@ h = starpu_data_get_sub_data(A_handle, 1, taskx);
 
 \fn starpu_data_handle_t starpu_data_vget_sub_data(starpu_data_handle_t root_data, unsigned depth, va_list pa)
 \ingroup Data_Partition
-\brief This function is similar to starpu_data_get_sub_data() but uses a
+This function is similar to starpu_data_get_sub_data() but uses a
 va_list for the parameter list.
 
 \fn void starpu_data_map_filters(starpu_data_handle_t root_data, unsigned nfilters, ...)
 \ingroup Data_Partition
-\brief Applies \p nfilters filters to the handle designated by
+Applies \p nfilters filters to the handle designated by
 \p root_handle recursively. \p nfilters pointers to variables of the type
 starpu_data_filter should be given.
 
 \fn void starpu_data_vmap_filters(starpu_data_handle_t root_data, unsigned nfilters, va_list pa)
 \ingroup Data_Partition
-\brief Applies \p nfilters filters to the handle designated by
+Applies \p nfilters filters to the handle designated by
 \p root_handle recursively. It uses a va_list of pointers to variables of
 the type starpu_data_filter.
 
@@ -112,13 +112,13 @@ starpu_data_filters.h.
 
 \fn void starpu_vector_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief Return in \p child_interface the \p id th element of the vector
+Return in \p child_interface the \p id th element of the vector
 represented by \p father_interface once partitioned in \p nparts chunks of
 equal size.
 
 \fn void starpu_vector_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief Return in \p child_interface the \p id th element of the vector
+Return in \p child_interface the \p id th element of the vector
 represented by \p father_interface once partitioned in \p nparts chunks of
 equal size with a shadow border <c>filter_arg_ptr</c>, thus getting a vector
 of size (n-2*shadow)/nparts+2*shadow. The <c>filter_arg_ptr</c> field
@@ -129,7 +129,7 @@ examples/filters/shadow.c
 
 \fn void starpu_vector_filter_list(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief Return in \p child_interface the \p id th element of the vector
+Return in \p child_interface the \p id th element of the vector
 represented by \p father_interface once partitioned into \p nparts chunks
 according to the <c>filter_arg_ptr</c> field of \p f. The
 <c>filter_arg_ptr</c> field must point to an array of \p nparts uint32_t
@@ -138,7 +138,7 @@ of the partition.
 
 \fn void starpu_vector_filter_divide_in_2(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief Return in \p child_interface the \p id th element of the vector
+Return in \p child_interface the \p id th element of the vector
 represented by \p father_interface once partitioned in <c>2</c> chunks of
 equal size, ignoring nparts. Thus, \p id must be <c>0</c> or <c>1</c>.
 
@@ -152,13 +152,13 @@ starpu_data_filters.h.
 
 \fn void starpu_matrix_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a dense Matrix along the x dimension, thus
+This partitions a dense Matrix along the x dimension, thus
 getting (x/\p nparts ,y) matrices. If \p nparts does not divide x, the
 last submatrix contains the remainder.
 
 \fn void starpu_matrix_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a dense Matrix along the x dimension, with a
+This partitions a dense Matrix along the x dimension, with a
 shadow border <c>filter_arg_ptr</c>, thus getting ((x-2*shadow)/\p
 nparts +2*shadow,y) matrices. If \p nparts does not divide x-2*shadow,
 the last submatrix contains the remainder. <b>IMPORTANT</b>: This can
@@ -168,13 +168,13 @@ examples/filters/shadow2d.c
 
 \fn void starpu_matrix_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a dense Matrix along the y dimension, thus
+This partitions a dense Matrix along the y dimension, thus
 getting (x,y/\p nparts) matrices. If \p nparts does not divide y, the
 last submatrix contains the remainder.
 
 \fn void starpu_matrix_filter_vertical_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a dense Matrix along the y dimension, with a
+This partitions a dense Matrix along the y dimension, with a
 shadow border <c>filter_arg_ptr</c>, thus getting
 (x,(y-2*shadow)/\p nparts +2*shadow) matrices. If \p nparts does not
 divide y-2*shadow, the last submatrix contains the remainder.
@@ -193,13 +193,13 @@ examples/filters/shadow3d.c
 
 \fn void starpu_block_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the X dimension, thus getting
+This partitions a block along the X dimension, thus getting
 (x/\p nparts ,y,z) 3D matrices. If \p nparts does not divide x, the last
 submatrix contains the remainder.
 
 \fn void starpu_block_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the X dimension, with a
+This partitions a block along the X dimension, with a
 shadow border <p>filter_arg_ptr</p>, thus getting
 ((x-2*shadow)/\p nparts +2*shadow,y,z) blocks. If \p nparts does not
 divide x, the last submatrix contains the remainder. <b>IMPORTANT</b>:
@@ -208,13 +208,13 @@ enforced for the shadowed parts.
 
 \fn void starpu_block_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the Y dimension, thus getting
+This partitions a block along the Y dimension, thus getting
 (x,y/\p nparts ,z) blocks. If \p nparts does not divide y, the last
 submatrix contains the remainder.
 
 \fn void starpu_block_filter_vertical_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the Y dimension, with a
+This partitions a block along the Y dimension, with a
 shadow border <p>filter_arg_ptr</p>, thus getting
 (x,(y-2*shadow)/\p nparts +2*shadow,z) 3D matrices. If \p nparts does not
 divide y, the last submatrix contains the remainder. <b>IMPORTANT</b>:
@@ -223,13 +223,13 @@ enforced for the shadowed parts.
 
 \fn void starpu_block_filter_depth_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the Z dimension, thus getting
+This partitions a block along the Z dimension, thus getting
 (x,y,z/\p nparts) blocks. If \p nparts does not divide z, the last
 submatrix contains the remainder.
 
 \fn void starpu_block_filter_depth_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block along the Z dimension, with a
+This partitions a block along the Z dimension, with a
 shadow border <p>filter_arg_ptr</p>, thus getting
 (x,y,(z-2*shadow)/\p nparts +2*shadow) blocks. If \p nparts does not
 divide z, the last submatrix contains the remainder. <b>IMPORTANT</b>:
@@ -246,11 +246,11 @@ starpu_data_filters.h.
 
 \fn void starpu_bcsr_filter_canonical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block-sparse matrix into dense matrices.
+This partitions a block-sparse matrix into dense matrices.
 
 \fn void starpu_csr_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 \ingroup Data_Partition
-\brief This partitions a block-sparse matrix into vertical
+This partitions a block-sparse matrix into vertical
 block-sparse matrices.
 
 */

doc/doxygen/chapters/api/initialization.doxy

@@ -51,6 +51,11 @@ be specified with the STARPU_NCUDA environment variable. (default =
 This is the number of OpenCL devices that StarPU can use. This can
 also be specified with the STARPU_NOPENCL environment variable.
 (default = -1)
+\var starpu_conf::nmic
+This is the number of MIC devices that StarPU can use. (default = -1)
+\var starpu_conf::nscc
+This is the number of SCC devices that StarPU can use. (default = -1)
+
 \var starpu_conf::use_explicit_workers_bindid
 If this flag is set, the starpu_conf::workers_bindid array indicates
 where the different workers are bound, otherwise StarPU automatically
@@ -83,6 +88,22 @@ environment variable. (default = 0)
 If the starpu_conf::use_explicit_workers_opencl_gpuid flag is set,
 this array contains the logical identifiers of the OpenCL devices to
 be used.
+
+\var starpu_conf::use_explicit_workers_mic_deviceid
+If this flag is set, the MIC workers will be attached to the MIC
+devices specified in the array starpu_conf::workers_mic_deviceid.
+(default = 0)
+\var starpu_conf::workers_mic_deviceid
+If the flag starpu_conf::use_explicit_workers_mic_deviceid is set, the
+array contains the logical identifiers of the MIC devices to be used.
+\var starpu_conf::use_explicit_workers_scc_deviceid
+If this flag is set, the SCC workers will be attached to the SCC
+devices specified in the array starpu_conf::workers_scc_deviceid.
+(default = 0)
+\var starpu_conf::workers_scc_deviceid
+If the flag starpu_conf::use_explicit_workers_scc_deviceid is set, the
+array contains the logical identifiers of the SCC devices to be used.
+
 \var starpu_conf::bus_calibrate
 If this flag is set, StarPU will recalibrate the bus.  If this value
 is equal to <c>-1</c>, the default value is used.  This can also be
@@ -108,6 +129,11 @@ still try varying combined worker sizes to look for the
 most efficient ones. This can also be specified with the
 STARPU_SINGLE_COMBINED_WORKER environment variable.
 (default = 0)
+
+\var starpu_conf::mic_sink_program_path
+Path to the kernel to execute on the MIC device, compiled for MIC
+architecture.
+
 \var starpu_conf::disable_asynchronous_copy
 This flag should be set to 1 to disable
 asynchronous copies between CPUs and all accelerators. This
@@ -139,6 +165,10 @@ asynchronous data transfers. This can also be specified at
 compilation time by giving to the configure script the
 option <c>--disable-asynchronous-opencl-copy</c>. (default
 = 0)
+
+\var starpu_conf::disable_asynchronous_mic_copy
+indicate if asynchronous copies to MIC devices should be disabled
+
 \var starpu_conf::cuda_opengl_interoperability
 Enable CUDA/OpenGL interoperation on these CUDA
 devices. This can be set to an array of CUDA device
@@ -163,7 +193,7 @@ flushing (which would disturb the trace).
 
 \fn int starpu_init(struct starpu_conf *conf)
 \ingroup Initialization_and_Termination
-\brief This is StarPU initialization method, which must be called prior to
+This is StarPU initialization method, which must be called prior to
 any other StarPU call. It is possible to specify StarPU’s
 configuration (e.g. scheduling policy, number of cores, ...) by
 passing a non-null argument. Default configuration is used if the
@@ -171,9 +201,15 @@ passed argument is NULL. Upon successful completion, this function
 returns 0. Otherwise, -ENODEV indicates that no worker was available
 (so that StarPU was not initialized).
 
+\fn int starpu_initialize(struct starpu_conf *user_conf, int *argc, char ***argv)
+\ingroup Initialization_and_Termination
+Alternative initialization method with argc and argv. This is used by
+MIC, MPI, and SCC implementation. Do not call starpu_init() and
+starpu_initialize() in the same program.
+
 \fn int starpu_conf_init(struct starpu_conf *conf)
 \ingroup Initialization_and_Termination
-\brief This function initializes the conf structure passed as argument with
+This function initializes the conf structure passed as argument with
 the default values. In case some configuration parameters are already
 specified through environment variables, starpu_conf_init initializes
 the fields of the structure according to the environment variables.
@@ -184,28 +220,28 @@ the argument was NULL.
 
 \fn void starpu_shutdown(void)
 \ingroup Initialization_and_Termination
-\brief This is StarPU termination method. It must be called at the end of the
+This is StarPU termination method. It must be called at the end of the
 application: statistics and other post-mortem debugging information
 are not guaranteed to be available until this method has been called.
 
 \fn int starpu_asynchronous_copy_disabled(void)
 \ingroup Initialization_and_Termination
-\brief Return 1 if asynchronous data transfers between CPU and accelerators
+Return 1 if asynchronous data transfers between CPU and accelerators
 are disabled.
 
 \fn int starpu_asynchronous_cuda_copy_disabled(void)
 \ingroup Initialization_and_Termination
-\brief Return 1 if asynchronous data transfers between CPU and CUDA
+Return 1 if asynchronous data transfers between CPU and CUDA
 accelerators are disabled.
 
 \fn int starpu_asynchronous_opencl_copy_disabled(void)
 \ingroup Initialization_and_Termination
-\brief Return 1 if asynchronous data transfers between CPU and OpenCL
+Return 1 if asynchronous data transfers between CPU and OpenCL
 accelerators are disabled.
 
 \fn void starpu_topology_print(FILE *f)
 \ingroup Initialization_and_Termination
-\brief Prints a description of the topology on f.
+Prints a description of the topology on f.
 
 */
 

doc/doxygen/chapters/api/lower_bound.doxy

@@ -8,38 +8,41 @@
 
 /*! \defgroup Theoretical_lower_bound_on_execution_time Theoretical lower bound on execution time
 
+\brief Compute theoretical upper computation efficiency bound
+corresponding to some actual execution.
+
 \fn void starpu_bound_start (int deps, int prio)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Start recording tasks (resets stats). \p deps tells whether
+Start recording tasks (resets stats). \p deps tells whether
 dependencies should be recorded too (this is quite expensive)
 
 \fn void starpu_bound_stop (void)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Stop recording tasks
+Stop recording tasks
 
 \fn void starpu_bound_print_dot (FILE *output)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Print the DAG that was recorded
+Print the DAG that was recorded
 
 \fn void starpu_bound_compute (double *res, double *integer_res, int integer)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Get theoretical upper bound (in ms) (needs glpk support
+Get theoretical upper bound (in ms) (needs glpk support
 detected by configure script). It returns 0 if some performance models
 are not calibrated.
 
 \fn void starpu_bound_print_lp (FILE *output)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Emit the Linear Programming system on \p output for the recorded
+Emit the Linear Programming system on \p output for the recorded
 tasks, in the lp format
 
 \fn void starpu_bound_print_mps (FILE *output)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Emit the Linear Programming system on \p output for the recorded
+Emit the Linear Programming system on \p output for the recorded
 tasks, in the mps format
 
 \fn void starpu_bound_print (FILE *output, int integer)
 \ingroup Theoretical_lower_bound_on_execution_time
-\brief Emit statistics of actual execution vs theoretical upper bound.
+Emit statistics of actual execution vs theoretical upper bound.
 \p integer permits to choose between integer solving (which takes a
 long time but is correct), and relaxed solving (which provides an
 approximate solution).

doc/doxygen/chapters/api/multiformat_data_interface.doxy

@@ -26,9 +26,19 @@
 \var starpu_multiformat_data_interface_ops::cuda_to_cpu_cl
         pointer to a codelet which converts from CUDA to CPU
 
+\struct starpu_multiformat_interface
+\ingroup Multiformat_Data_Interface
+\var starpu_multiformat_interface::id
+\var starpu_multiformat_interface::cpu_ptr
+\var starpu_multiformat_interface::cuda_ptr
+\var starpu_multiformat_interface::opencl_ptr
+\var starpu_multiformat_interface::mic_ptr
+\var starpu_multiformat_interface::nx
+\var starpu_multiformat_interface::ops
+
 \fn void starpu_multiformat_data_register(starpu_data_handle_t *handle, unsigned home_node, void *ptr, uint32_t nobjects, struct starpu_multiformat_data_interface_ops *format_ops)
 \ingroup Multiformat_Data_Interface
-\brief Register a piece of data that can be represented in different
+Register a piece of data that can be represented in different
 ways, depending upon the processing unit that manipulates it. It
 allows the programmer, for instance, to use an array of structures
 when working on a CPU, and a structure of arrays when working on a
@@ -37,18 +47,18 @@ describes the format.
 
 \def STARPU_MULTIFORMAT_GET_CPU_PTR(void *interface)
 \ingroup Multiformat_Data_Interface
-\brief returns the local pointer to the data with CPU format.
+returns the local pointer to the data with CPU format.
 
 \def STARPU_MULTIFORMAT_GET_CUDA_PTR(void *interface)
 \ingroup Multiformat_Data_Interface
-\brief returns the local pointer to the data with CUDA format.
+returns the local pointer to the data with CUDA format.
 
 \def STARPU_MULTIFORMAT_GET_OPENCL_PTR(void *interface)
 \ingroup Multiformat_Data_Interface
-\brief returns the local pointer to the data with OpenCL format.
+returns the local pointer to the data with OpenCL format.
 
 \def STARPU_MULTIFORMAT_GET_NX (void *interface)
 \ingroup Multiformat_Data_Interface
-\brief returns the number of elements in the data.
+returns the number of elements in the data.
 
 */

doc/doxygen/chapters/api/performance_model.doxy

@@ -9,7 +9,7 @@
 /*! \defgroup Performance_Model Performance Model
 
 \struct starpu_perfmodel
-\brief Ontains all information about a performance model. At least the
+\brief Contains all information about a performance model. At least the
 type and symbol fields have to be filled when defining a performance
 model for a codelet. For compatibility, make sure to initialize the
 whole structure to zero, either by using explicit memset, or by
@@ -151,59 +151,63 @@ Provided by the application
 
 \fn int starpu_perfmodel_load_symbol(const char *symbol, struct starpu_perfmodel *model)
 \ingroup Performance_Model
-\brief loads a given performance model. The model structure has to be
+loads a given performance model. The model structure has to be
 completely zero, and will be filled with the information saved in
 <c>$STARPU_HOME/.starpu</c>. The function is intended to be used by
 external tools that should read the performance model files.
 
 \fn int starpu_perfmodel_unload_model(struct starpu_perfmodel *model)
 \ingroup Performance_Model
-\brief unloads the given model which has been previously loaded
+unloads the given model which has been previously loaded
 through the function starpu_perfmodel_load_symbol()
 
 \fn void starpu_perfmodel_debugfilepath(struct starpu_perfmodel *model, enum starpu_perfmodel_archtype arch, char *path, size_t maxlen, unsigned nimpl)
 \ingroup Performance_Model
-\brief returns the path to the debugging information for the performance model.
+returns the path to the debugging information for the performance model.
 
 \fn void starpu_perfmodel_get_arch_name(enum starpu_perfmodel_archtype arch, char *archname, size_t maxlen, unsigned nimpl)
 \ingroup Performance_Model
-\brief returns the architecture name for \p arch
+returns the architecture name for \p arch
 
 \fn enum starpu_perfmodel_archtype starpu_worker_get_perf_archtype(int workerid)
 \ingroup Performance_Model
-\brief returns the architecture type of a given worker.
+returns the architecture type of a given worker.
 
 \fn int starpu_perfmodel_list(FILE *output)
 \ingroup Performance_Model
-\brief prints a list of all performance models on \p output
+prints a list of all performance models on \p output
 
 \fn void starpu_perfmodel_print(struct starpu_perfmodel *model, enum starpu_perfmodel_archtype arch, unsigned nimpl, char *parameter, uint32_t *footprint, FILE *output)
 \ingroup Performance_Model
-\brief todo
+todo
 
 \fn int starpu_perfmodel_print_all(struct starpu_perfmodel *model, char *arch, char *parameter, uint32_t *footprint, FILE *output)
 \ingroup Performance_Model
-\brief todo
+todo
 
 \fn void starpu_bus_print_bandwidth(FILE *f)
 \ingroup Performance_Model
-\brief prints a matrix of bus bandwidths on \p f.
+prints a matrix of bus bandwidths on \p f.
 
 \fn void starpu_bus_print_affinity(FILE *f)
 \ingroup Performance_Model
-\brief prints the affinity devices on \p f.
-
-\fn void starpu_topology_print(FILE *f)
-\ingroup Performance_Model
-\brief prints a description of the topology on \p f.
+prints the affinity devices on \p f.
 
 \fn void starpu_perfmodel_update_history(struct starpu_perfmodel *model, struct starpu_task *task, enum starpu_perfmodel_archtype arch, unsigned cpuid, unsigned nimpl, double measured);
 \ingroup Performance_Model
-\brief This feeds the performance model model with an explicit
+This feeds the performance model model with an explicit
 measurement measured, in addition to measurements done by StarPU
 itself. This can be useful when the application already has an
 existing set of measurements done in good conditions, that StarPU
 could benefit from instead of doing on-line measurements. And example
 of use can be see in \ref Performance_model_example.
 
+\fn double starpu_get_bandwidth_RAM_CUDA(unsigned cudadev)
+\ingroup Performance_Model
+Used to compute the velocity of resources
+
+\fn double starpu_get_latency_RAM_CUDA(unsigned cudadev)
+\ingroup Performance_Model
+Used to compute the velocity of resources
+
 */

doc/doxygen/chapters/api/profiling.doxy

@@ -100,7 +100,7 @@ starpu_profiling_worker_get_info()
 
 \fn int starpu_profiling_status_set(int status)
 \ingroup Profiling
-\brief This function sets the profiling status. Profiling is activated
+This function sets the profiling status. Profiling is activated
 by passing STARPU_PROFILING_ENABLE in status. Passing
 STARPU_PROFILING_DISABLE disables profiling. Calling this function
 resets all profiling measurements. When profiling is enabled, the
@@ -111,17 +111,17 @@ previous status is returned.
 
 \fn int starpu_profiling_status_get(void)
 \ingroup Profiling
-\brief Return the current profiling status or a negative value in case
+Return the current profiling status or a negative value in case
 there was an error.
 
 \fn void starpu_profiling_set_id(int new_id)
 \ingroup Profiling
-\brief This function sets the ID used for profiling trace filename. It
+This function sets the ID used for profiling trace filename. It
 needs to be called before starpu_init().
 
 \fn int starpu_profiling_worker_get_info(int workerid, struct starpu_profiling_worker_info *worker_info)
 \ingroup Profiling
-\brief Get the profiling info associated to the worker identified by
+Get the profiling info associated to the worker identified by
 \p workerid, and reset the profiling measurements. If the argument \p
 worker_info is NULL, only reset the counters associated to worker
 \p workerid. Upon successful completion, this function returns 0.
@@ -129,47 +129,47 @@ Otherwise, a negative value is returned.
 
 \fn int starpu_bus_get_profiling_info(int busid, struct starpu_profiling_bus_info *bus_info)
 \ingroup Profiling
-\brief todo
+todo
 
 \fn int starpu_bus_get_count(void)
 \ingroup Profiling
-\brief Return the number of buses in the machine
+Return the number of buses in the machine
 
 \fn int starpu_bus_get_id(int src, int dst)
 \ingroup Profiling
-\brief Return the identifier of the bus between \p src and \p dst
+Return the identifier of the bus between \p src and \p dst
 
 \fn int starpu_bus_get_src(int busid)
 \ingroup Profiling
-\brief Return the source point of bus \p busid
+Return the source point of bus \p busid
 
 \fn int starpu_bus_get_dst(int busid)
 \ingroup Profiling
-\brief Return the destination point of bus \p busid
+Return the destination point of bus \p busid
 
 \fn double starpu_timing_timespec_delay_us(struct timespec *start, struct timespec *end)
 \ingroup Profiling
-\brief Returns the time elapsed between \p start and \p end in microseconds.
+Returns the time elapsed between \p start and \p end in microseconds.
 
 \fn double starpu_timing_timespec_to_us(struct timespec *ts)
 \ingroup Profiling
-\brief Converts the given timespec \p ts into microseconds
+Converts the given timespec \p ts into microseconds
 
 \fn void starpu_profiling_bus_helper_display_summary(void)
 \ingroup Profiling
-\brief Displays statistics about the bus on stderr. if the environment
+Displays statistics about the bus on stderr. if the environment
 variable STARPU_BUS_STATS is defined. The function is called
 automatically by starpu_shutdown().
 
 \fn void starpu_profiling_worker_helper_display_summary(void)
 \ingroup Profiling
-\brief Displays statistics about the workers on stderr if the
+Displays statistics about the workers on stderr if the
 environment variable STARPU_WORKER_STATS is defined. The function is
 called automatically by starpu_shutdown().
 
 \fn void starpu_data_display_memory_stats()
 \ingroup Profiling
-\brief Display statistics about the current data handles registered
+Display statistics about the current data handles registered
 within StarPU. StarPU must have been configured with the option
 <c>--enable-memory-stats</c> (see \ref Memory_feedback).
 

doc/doxygen/chapters/api/running_driver.doxy

@@ -27,11 +27,12 @@ Initialize the given driver. Returns 0 on success, <c>-EINVAL</c> if
 \ingroup Running_Drivers
 Run the driver once, then returns 0 on success, <c>-EINVAL</c> if <c>d->type</c> is not a valid ::starpu_worker_archtype.
 
-Function: int starpu_driver_deinit (struct starpu_driver *d)
+\fn int starpu_driver_deinit(struct starpu_driver *d)
 \ingroup Running Drivers
-Deinitialize the given driver. Returns 0 on success, <c>-EINVAL</c> if <c>d->type</c> is not a valid ::starpu_worker_archtype.
+Deinitialize the given driver. Returns 0 on success, <c>-EINVAL</c> if
+<c>d->type</c> is not a valid ::starpu_worker_archtype.
 
-Function: void starpu_drivers_request_termination (void)
+\fn void starpu_drivers_request_termination(void)
 \ingroup Running Drivers
 Notify all running drivers they should terminate.
 

doc/doxygen/chapters/api/scheduling_context_hypervisor.doxy

@@ -8,19 +8,6 @@
 
 /*! \defgroup Scheduling_Context_Hypervisor Scheduling Context Hypervisor
 
-\struct starpu_sched_ctx_performance_counters
-\ingroup Scheduling_Context_Hypervisor
-\var starpu_sched_ctx_performance_counters::notify_idle_cycle
-        Informs the hypervisor for how long a worker has been idle in the specified context
-\var starpu_sched_ctx_performance_counters::notify_idle_end
-        Informs the hypervisor that after a period of idle, the worker has just executed a task in the specified context. The idle counter it though reset.
-\var starpu_sched_ctx_performance_counters::notify_pushed_task
-        Notifies the hypervisor a task has been scheduled on the queue of the worker corresponding to the specified context
-\var starpu_sched_ctx_performance_counters::notify_poped_task
-        Informs the hypervisor a task executing a specified number of instructions has been poped from the worker
-\var starpu_sched_ctx_performance_counters::notify_post_exec_hook
-        Notifies the hypervisor a task has just been executed
-
 \struct sc_hypervisor_policy
 \ingroup Scheduling_Context_Hypervisor
 \brief This structure contains all the methods that implement a hypervisor resizing policy.

doc/doxygen/chapters/api/scheduling_contexts.doxy

@@ -1,4 +1,4 @@
-/*
+*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux 1
  * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
@@ -16,6 +16,24 @@ starpu tasks to them and we schedule them with the policy assigned to
 the context. Scheduling contexts can be created, deleted and modified
 dynamically.
 
+\struct starpu_sched_ctx_performance_counters
+\brief Performance counters used by the starpu to indicate the
+hypervisor how the application and the resources are executing.
+\ingroup Scheduling_Contexts
+\var starpu_sched_ctx_performance_counters::notify_idle_cycle
+        Informs the hypervisor for how long a worker has been idle in the specified context
+\var starpu_sched_ctx_performance_counters::notify_idle_end
+        Informs the hypervisor that after a period of idle, the worker has just executed a task in the specified context. The idle counter it though reset.
+\var starpu_sched_ctx_performance_counters::notify_pushed_task
+        Notifies the hypervisor a task has been scheduled on the queue of the worker corresponding to the specified context
+\var starpu_sched_ctx_performance_counters::notify_poped_task
+        Informs the hypervisor a task executing a specified number of instructions has been poped from the worker
+\var starpu_sched_ctx_performance_counters::notify_post_exec_hook
+        Notifies the hypervisor a task has just been executed
+
+@name Scheduling Contexts Basic API
+\ingroup Scheduling_Contexts
+
 \fn unsigned starpu_sched_ctx_create(const char *policy_name, int *workerids_ctx, int nworkers_ctx, const char *sched_ctx_name)
 \ingroup Scheduling_Contexts
 This function creates a scheduling context which uses the scheduling
@@ -26,6 +44,10 @@ just been created. It will be further used to indicate the context the
 tasks will be submitted to. The return value should be at most
 STARPU_NMAX_SCHED_CTXS.
 
+\fn unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const char *sched_name, int min_ncpus, int max_ncpus, int min_ngpus, int max_ngpus, unsigned allow_overlap)
+\ingroup Scheduling_Contexts
+Create a context indicating an approximate interval of resources
+
 \fn void starpu_sched_ctx_delete(unsigned sched_ctx_id)
 \ingroup Scheduling_Contexts
 Delete scheduling context \p sched_ctx_id and transfer remaining
@@ -43,6 +65,112 @@ This function removes the workers in \p workerids_ctx from the context
 \p sched_ctx_id. The last argument cannot be greater than
 STARPU_NMAX_SCHED_CTXS.
 
+\fn void starpu_sched_ctx_set_inheritor(unsigned sched_ctx_id, unsigned inheritor)
+\ingroup Scheduling_Contexts
+Indicate which context whill inherit the resources of this context
+when he will be deleted.
+
+\fn void starpu_sched_ctx_set_context(unsigned *sched_ctx_id)
+\ingroup Scheduling_Contexts
+Set the scheduling context the subsequent tasks will be submitted to
+
+\fn unsigned starpu_sched_ctx_get_context(void)
+\ingroup Scheduling_Contexts
+Return the scheduling context the tasks are currently submitted to
+
+\fn void starpu_sched_ctx_stop_task_submission(void)
+\ingroup Scheduling_Contexts
+Stop submitting tasks from the empty context list until the next time
+the context has time to check the empty context list
+
+\fn void starpu_sched_ctx_finished_submit(unsigned sched_ctx_id);
+\ingroup Scheduling_Contexts
+Indicate starpu that the application finished submitting to this
+context in order to move the workers to the inheritor as soon as
+possible.
+
+\fn unsigned starpu_sched_ctx_get_nworkers(unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Return the number of workers managed by the specified contexts
+(Usually needed to verify if it manages any workers or if it should be
+blocked)
+
+\fn unsigned starpu_sched_ctx_get_nshared_workers(unsigned sched_ctx_id, unsigned sched_ctx_id2)
+\ingroup Scheduling_Contexts
+    Return the number of workers shared by two contexts.
+
+\fn unsigned starpu_sched_ctx_contains_worker(int workerid, unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Return 1 if the worker belongs to the context and 0 otherwise
+
+\fn unsigned starpu_sched_ctx_overlapping_ctxs_on_worker(int workerid)
+\ingroup Scheduling_Contexts
+Check if a worker is shared between several contexts
+
+\fn unsigned starpu_sched_ctx_is_ctxs_turn(int workerid, unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Manage sharing of resources between contexts: checkOB which ctx has
+its turn to pop.
+
+\fn void starpu_sched_ctx_set_turn_to_other_ctx(int workerid, unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Manage sharing of resources between contexts: by default a round_robin
+strategy is executed but the user can interfere to tell which ctx has
+its turn to pop.
+
+\fn double starpu_sched_ctx_get_max_time_worker_on_ctx(void)
+\ingroup Scheduling_Contexts
+Time sharing a resources, indicate how long a worker has been active
+in the current sched_ctx.
+
+@name Scheduling Context Priorities
+\ingroup Scheduling_Contexts
+
+\def STARPU_MIN_PRIO
+\ingroup Scheduling_Contexts
+Provided for legacy reasons.
+
+\def STARPU_MAX_PRIO
+\ingroup Scheduling_Contexts
+Provided for legacy reasons.
+
+\def STARPU_DEFAULT_PRIO
+\ingroup Scheduling_Contexts
+By convention, the default priority level should be 0 so that we can
+statically allocate tasks with a default priority.
+
+\fn int starpu_sched_ctx_set_min_priority(unsigned sched_ctx_id, int min_prio)
+\ingroup Scheduling_Contexts
+Defines the minimum task priority level supported by the scheduling
+policy of the given scheduler context. 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 function
+starpu_sched_ctx_get_min_priority(). This function should only
+be called from the initialization method of the scheduling policy, and
+should not be used directly from the application.
+
+\fn int starpu_sched_ctx_set_max_priority(unsigned sched_ctx_id, int max_prio)
+\ingroup Scheduling_Contexts
+Defines the maximum priority level supported by the scheduling policy
+of the given scheduler context. The default maximum priority level is
+1. The application may access that value by calling the
+starpu_sched_ctx_get_max_priority function. This function should only
+be called from the initialization method of the scheduling policy, and
+should not be used directly from the application.
+
+\fn int starpu_sched_ctx_get_min_priority(unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Returns the current minimum priority level supported by the scheduling
+policy of the given scheduler context.
+
+\fn int starpu_sched_ctx_get_max_priority(unsigned sched_ctx_id)
+\ingroup Scheduling_Contexts
+Returns the current maximum priority level supported by the scheduling
+policy of the given scheduler context.
+
+@name Scheduling Context Worker Collection
+\ingroup Scheduling_Contexts
+
 \struct starpu_worker_collection
 \ingroup Scheduling_Contexts
 \brief A scheduling context manages a collection of workers that can
@@ -69,9 +197,9 @@ structures(like tree) implementations are foreseen.
 \var starpu_worker_collection::deinit
         Deinitialize the colection
 
-\fn struct starpu_worker_collection* starpu_sched_ctx_create_worker_collection(unsigned sched_ctx_id, int type)
+\fn struct starpu_worker_collection* starpu_sched_ctx_create_worker_collection(unsigned sched_ctx_id, enum starpu_worker_collection_type type)
 \ingroup Scheduling_Contexts
-Create a worker collection of the type indicated by the last parameterx
+Create a worker collection of the type indicated by the last parameter
 for the context specified through the first parameter.
 
 \fn void starpu_sched_ctx_delete_worker_collection(unsigned sched_ctx_id)
@@ -82,50 +210,24 @@ Delete the worker collection of the specified scheduling context
 \ingroup Scheduling_Contexts
 Return the worker collection managed by the indicated context
 
-\fn void starpu_sched_ctx_set_context(unsigned *sched_ctx_id)
+@name Scheduling Context Link with Hypervisor
 \ingroup Scheduling_Contexts
-Set the scheduling context the subsequent tasks will be submitted to
 
-\fn unsigned starpu_sched_ctx_get_context(void)
+\fn void starpu_sched_ctx_set_perf_counters(unsigned sched_ctx_id, struct starpu_sched_ctx_performance_counters *perf_counters)
 \ingroup Scheduling_Contexts
-Return the scheduling context the tasks are currently submitted to
+Indicates to starpu the pointer to the performance counter
 
-\fn unsigned starpu_sched_ctx_get_nworkers(unsigned sched_ctx_id)
+\fn void starpu_sched_ctx_call_pushed_task_cb(int workerid, unsigned sched_ctx_id)
 \ingroup Scheduling_Contexts
-Return the number of workers managed by the specified contexts
-(Usually needed to verify if it manages any workers or if it should be
-blocked)
+Callback that lets the scheduling policy tell the hypervisor that a
+task was pushed on a worker
 
-\fn unsigned starpu_sched_ctx_get_nshared_workers(unsigned sched_ctx_id, unsigned sched_ctx_id2)
+\fn void starpu_sched_ctx_notify_hypervisor_exists(void)
 \ingroup Scheduling_Contexts
-    Return the number of workers shared by two contexts.
+Allow the hypervisor to let starpu know he's initialised
 
-\fn int starpu_sched_ctx_set_min_priority(unsigned sched_ctx_id, int min_prio)
+\fn unsigned starpu_sched_ctx_check_if_hypervisor_exists(void)
 \ingroup Scheduling_Contexts
-Defines the minimum task priority level supported by the scheduling
-policy of the given scheduler context. 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
-starpu_sched_ctx_get_min_priority function. This function should only
-be called from the initialization method of the scheduling policy, and
-should not be used directly from the application.
+Ask starpu if he is informed if the hypervisor is initialised
 
-\fn int starpu_sched_ctx_set_max_priority(unsigned sched_ctx_id, int max_prio)
-\ingroup Scheduling_Contexts
-Defines the maximum priority level supported by the scheduling policy
-of the given scheduler context. The default maximum priority level is
-1. The application may access that value by calling the
-starpu_sched_ctx_get_max_priority function. This function should only
-be called from the initialization method of the scheduling policy, and
-should not be used directly from the application.
-
-\fn int starpu_sched_ctx_get_min_priority(unsigned sched_ctx_id)
-\ingroup Scheduling_Contexts
-Returns the current minimum priority level supported by the scheduling
-policy of the given scheduler context.
-
-\fn int starpu_sched_ctx_get_max_priority(unsigned sched_ctx_id)
-\ingroup Scheduling_Contexts
-Returns the current maximum priority level supported by the scheduling
-policy of the given scheduler context.
 */

doc/doxygen/chapters/api/scheduling_policy.doxy

@@ -63,6 +63,16 @@ starpu_init().
 Return an NULL-terminated array of all the predefined scheduling
 policies.
 
+\fn void starpu_worker_get_sched_condition(int workerid, starpu_pthread_mutex_t **sched_mutex, starpu_pthread_cond_t **sched_cond)
+\ingroup Scheduling_Policy
+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 multiple workers may use the same
+condition variable. For instance, in the case of a scheduling strategy
+with a single task queue, the same condition variable would be used to
+block and wake up all workers.
+
 \fn void starpu_sched_ctx_set_policy_data(unsigned sched_ctx_id, void * policy_data)
 \ingroup Scheduling_Policy
 Each scheduling policy uses some specific data (queues, variables,