doc/doxygen/chapters/api: add types for struct fields

doc/doxygen/chapters/api/codelet_and_tasks.doxy

@@ -155,7 +155,7 @@ initialize the whole structure to zero, either by using explicit
 memset, or the function starpu_codelet_init(), or by letting the
 compiler implicitly do it in e.g. static storage case.
 \ingroup API_Codelet_And_Tasks
-\var starpu_codelet::where
+\var uint32_t starpu_codelet::where
 Optional field to indicate which types of processing units are able to
 execute the codelet. The different values ::STARPU_CPU, ::STARPU_CUDA,
 ::STARPU_OPENCL can be combined to specify on which types of processing
@@ -165,38 +165,38 @@ devices while ::STARPU_OPENCL indicates that it is only available on
 OpenCL devices. If the field is unset, its value will be automatically
 set based on the availability of the XXX_funcs fields defined below.
 
-\var starpu_codelet::can_execute
+\var int (*starpu_codelet::can_execute)(unsigned workerid, struct starpu_task *task, unsigned nimpl)
 Define a function which should return 1 if the worker designated by
 workerid can execute the <c>nimpl</c>th implementation of the given
 task, 0 otherwise.
 
-\var starpu_codelet::type
+\var enum starpu_codelet_type starpu_codelet::type
 Optional field to specify the type of the codelet. The default is
 ::STARPU_SEQ, i.e. usual sequential implementation. Other values
 (::STARPU_SPMD or ::STARPU_FORKJOIN declare that a parallel implementation
 is also available. See \ref ParallelTasks for details.
 
-\var starpu_codelet::max_parallelism
+\var int starpu_codelet::max_parallelism
 Optional field. If a parallel implementation is available, this
 denotes the maximum combined worker size that StarPU will use to
 execute parallel tasks for this codelet.
 
-\var starpu_codelet::cpu_func
+\var starpu_cpu_func_t starpu_codelet::cpu_func
 \deprecated
 Optional field which has been made deprecated. One should use instead
 the field starpu_codelet::cpu_funcs.
 
-\var starpu_codelet::cuda_func
+\var starpu_cuda_func_t starpu_codelet::cuda_func
 \deprecated
 Optional field which has been made deprecated. One should use instead
 the starpu_codelet::cuda_funcs field.
 
-\var starpu_codelet::opencl_func
+\var starpu_opencl_func_t starpu_codelet::opencl_func
 \deprecated
 Optional field which has been made deprecated. One should use instead
 the starpu_codelet::opencl_funcs field.
 
-\var starpu_codelet::cpu_funcs
+\var starpu_cpu_func_t starpu_codelet::cpu_funcs[STARPU_MAXIMPLEMENTATIONS]
 Optional array of function pointers to the CPU implementations of the
 codelet. It must be terminated by a NULL value. The functions
 prototype must be:
@@ -210,13 +210,13 @@ starpu_codelet::where is set, then the field starpu_codelet::cpu_funcs
 is ignored if ::STARPU_CPU does not appear in the field
 starpu_codelet::where, it must be non-null otherwise.
 
-\var starpu_codelet::cpu_funcs_name
+\var char *starpu_codelet::cpu_funcs_name[STARPU_MAXIMPLEMENTATIONS]
 Optional array of strings which provide the name of the CPU functions
 referenced in the array starpu_codelet::cpu_funcs. This can be used
 when running on MIC devices or the SCC platform, for StarPU to simply
 look up the MIC function implementation through its name.
 
-\var starpu_codelet::cuda_funcs
+\var starpu_cuda_func_t starpu_codelet::cuda_funcs[STARPU_MAXIMPLEMENTATIONS]
 Optional array of function pointers to the CUDA implementations of the
 codelet. It must be terminated by a NULL value. The functions must be
 host-functions written in the CUDA runtime API. Their prototype must
@@ -228,11 +228,11 @@ If the field starpu_codelet::where is set, then the field
 starpu_codelet::cuda_funcs is ignored if ::STARPU_CUDA does not appear
 in the field starpu_codelet::where, it must be non-null otherwise.
 
-\var starpu_codelet::cuda_flags
+\var char starpu_codelet::cuda_flags[STARPU_MAXIMPLEMENTATIONS]
 Optional array of flags for CUDA execution. They specify some semantic details
 about CUDA kernel execution, such as asynchronous execution.
 
-\var starpu_codelet::opencl_funcs
+\var starpu_opencl_func_t starpu_codelet::opencl_funcs[STARPU_MAXIMPLEMENTATIONS]
 Optional array of function pointers to the OpenCL implementations of
 the codelet. It must be terminated by a NULL value. The functions
 prototype must be:
@@ -244,11 +244,11 @@ starpu_codelet::opencl_funcs is ignored if ::STARPU_OPENCL does not
 appear in the field starpu_codelet::where, it must be non-null
 otherwise.
 
-\var starpu_codelet::opencl_flags
+\var char starpu_codelet::opencl_flags[STARPU_MAXIMPLEMENTATIONS]
 Optional array of flags for OpenCL execution. They specify some semantic details
 about OpenCL kernel execution, such as asynchronous execution.
 
-\var starpu_codelet::mic_funcs
+\var starpu_mic_func_t starpu_codelet::mic_funcs[STARPU_MAXIMPLEMENTATIONS]
 Optional array of function pointers to a function which returns the
 MIC implementation of the codelet. It must be terminated by a NULL
 value. The functions prototype must be:
@@ -261,7 +261,7 @@ in the field starpu_codelet::where. It can be null if
 starpu_codelet::cpu_funcs_name is non-NULL, in which case StarPU will
 simply make a symbol lookup to get the implementation.
 
-\var starpu_codelet::scc_funcs
+\var starpu_scc_func_t starpu_codelet::scc_funcs[STARPU_MAXIMPLEMENTATIONS]
 Optional array of function pointers to a function which returns the
 SCC implementation of the codelet. It must be terminated by a NULL value.
 The functions prototype must be:
@@ -274,7 +274,7 @@ in the field starpu_codelet::where. It can be null if
 starpu_codelet::cpu_funcs_name is non-NULL, in which case StarPU will
 simply make a symbol lookup to get the implementation.
 
-\var starpu_codelet::nbuffers
+\var int starpu_codelet::nbuffers
 Specify the number of arguments taken by the codelet. These arguments are
 managed by the DSM and are accessed from the <c>void *buffers[]</c> array. The
 constant argument passed with the field starpu_task::cl_arg is not counted in
@@ -284,7 +284,7 @@ access modes will be set in starpu_task::nbuffers and starpu_task::modes or
 starpu_task::dyn_modes, which thus permits to define codelets with a varying
 number of data.
 
-\var starpu_codelet::modes
+\var enum starpu_data_access_mode starpu_codelet::modes[STARPU_NMAXBUFS]
 Is an array of ::starpu_data_access_mode. It describes the required
 access modes to the data neeeded by the codelet (e.g. ::STARPU_RW). The
 number of entries in this array must be specified in the field
@@ -292,7 +292,7 @@ starpu_codelet::nbuffers, and should not exceed \ref STARPU_NMAXBUFS. If
 unsufficient, this value can be set with the configure option
 \ref enable-maxbuffers "--enable-maxbuffers".
 
-\var starpu_codelet::dyn_modes
+\var enum starpu_data_access_mode *starpu_codelet::dyn_modes
 Is an array of ::starpu_data_access_mode. It describes the required
 access modes to the data needed by the codelet (e.g. ::STARPU_RW).
 The number of entries in this array must be specified in the field
@@ -301,20 +301,20 @@ number of datas greater than \ref STARPU_NMAXBUFS (see \ref
 SettingTheDataHandlesForATask). When defining a codelet, one
 should either define this field or the field starpu_codelet::modes defined above.
 
-\var starpu_codelet::specific_nodes.
+\var unsigned starpu_codelet::specific_nodes
 Default value is 0. If this flag is set, StarPU will not systematically
 send all data to the memory node where the task will be executing, it
 will read the starpu_codelet::nodes or starpu_codelet::dyn_nodes array to
 determine, for each data, whether to send it on the memory node where the task
 will be executing (-1), or on a specific node (!= -1).
 
-\var starpu_codelet::nodes.
+\var int starpu_codelet::nodes[STARPU_NMAXBUFS]
 Optional field. When starpu_codelet::specific_nodes is 1, this specifies
 the memory nodes where each data should be sent to for task execution.
 The number of entries in this array is starpu_codelet::nbuffers, and should
 not exceed \ref STARPU_NMAXBUFS.
 
-\var starpu_codelet::dyn_nodes
+\var int *starpu_codelet::dyn_nodes
 Optional field. When starpu_codelet::specific_nodes is 1, this specifies
 the memory nodes where each data should be sent to for task execution.
 The number of entries in this array is starpu_codelet::nbuffers.
@@ -324,25 +324,25 @@ SettingTheDataHandlesForATask). When defining a codelet, one
 should either define this field or the field starpu_codelet::nodes defined
 above.
 
-\var starpu_codelet::model
+\var struct starpu_perfmodel *starpu_codelet::model
 Optional pointer to the task duration performance model associated to
 this codelet. This optional field is ignored when set to <c>NULL</c> or when
 its field starpu_perfmodel::symbol is not set.
 
-\var starpu_codelet::power_model
+\var struct starpu_perfmodel *starpu_codelet::power_model
 Optional pointer to the task power consumption performance model
 associated to this codelet. This optional field is ignored when set to
 <c>NULL</c> or when its field starpu_perfmodel::field is not set. In
 the case of parallel codelets, this has to account for all processing
 units involved in the parallel execution.
 
-\var starpu_codelet::per_worker_stats
+\var unsigned long starpu_codelet::per_worker_stats[STARPU_NMAXWORKERS]
 Optional array for statistics collected at runtime: this is filled by
 StarPU and should not be accessed directly, but for example by calling
 the function starpu_codelet_display_stats() (See
 starpu_codelet_display_stats() for details).
 
-\var starpu_codelet::name
+\var const char *starpu_codelet::name
 Optional name of the codelet. This can be useful for debugging
 purposes.
 
@@ -356,9 +356,9 @@ possible, e.g. when using C++.
 \struct starpu_data_descr
 \ingroup API_Codelet_And_Tasks
 This type is used to describe a data handle along with an access mode.
-\var starpu_data_descr::handle
+\var starpu_data_handle_t starpu_data_descr::handle
 describes a data
-\var starpu_data_descr::mode
+\var enum starpu_data_access_mode starpu_data_descr::mode
 describes its access mode
 
 \struct starpu_task
@@ -371,11 +371,11 @@ programmer has to zero the structure starpu_task and to fill the
 different fields properly. The indicated default values correspond to
 the configuration of a task allocated with starpu_task_create().
 
-\var starpu_task::name
+\var const char *starpu_task::name
 Optional name of the task. This can be useful for debugging
 purposes.
 
-\var starpu_task::cl
+\var struct starpu_codelet *starpu_task::cl
 Is a pointer to the corresponding structure starpu_codelet. This
 describes where the kernel should be executed, and supplies the
 appropriate implementations. When set to NULL, no code is executed
@@ -386,18 +386,18 @@ field starpu_task::handles to specify the data handles accessed
 by the task. The access modes are now defined in the field
 starpu_codelet::modes.
 
-\var starpu_task::nbuffers
+\var int starpu_task::nbuffers
 Specifies the number of buffers. This is only used when starpu_codelet::nbuffers
 is STARPU_VARIABLE_NBUFFERS.
 
-\var starpu_task::handles
+\var starpu_data_handle_t starpu_task::handles[STARPU_NMAXBUFS]
 Is an array of ::starpu_data_handle_t. It specifies the handles to the
 different pieces of data accessed by the task. The number of entries
 in this array must be specified in the field starpu_codelet::nbuffers,
 and should not exceed \ref STARPU_NMAXBUFS. If unsufficient, this value can
 be set with the configure option \ref enable-maxbuffers "--enable-maxbuffers".
 
-\var starpu_task::dyn_handles
+\var starpu_data_handle_t *starpu_task::dyn_handles
 Is an array of ::starpu_data_handle_t. It specifies the handles to the
 different pieces of data accessed by the task. The number of entries
 in this array must be specified in the field starpu_codelet::nbuffers.
@@ -406,16 +406,16 @@ than \ref STARPU_NMAXBUFS (see \ref SettingTheDataHandlesForATask).
 When defining a task, one should either define this field or the field
 starpu_task::handles defined above.
 
-\var starpu_task::interfaces
+\var void *starpu_task::interfaces[STARPU_NMAXBUFS]
 The actual data pointers to the memory node where execution will
 happen, managed by the DSM.
 
-\var starpu_task::dyn_interfaces
+\var void **starpu_task::dyn_interfaces
 The actual data pointers to the memory node where execution will
 happen, managed by the DSM. Is used when the field
 starpu_task::dyn_handles is defined.
 
-\var starpu_task::modes
+\var enum starpu_data_access_mode starpu_task::modes[STARPU_NMAXBUFS]
 Is used only when starpu_codelet::nbuffers is STARPU_VARIABLE_NBUFFERS.
 It is an array of ::starpu_data_access_mode. It describes the required
 access modes to the data neeeded by the codelet (e.g. ::STARPU_RW). The
@@ -424,7 +424,7 @@ starpu_task::nbuffers, and should not exceed \ref STARPU_NMAXBUFS. If
 unsufficient, this value can be set with the configure option
 \ref enable-maxbuffers "--enable-maxbuffers".
 
-\var starpu_task::dyn_modes
+\var enum starpu_data_access_mode *starpu_task::dyn_modes
 Is used only when starpu_codelet::nbuffers is STARPU_VARIABLE_NBUFFERS.
 It is an array of ::starpu_data_access_mode. It describes the required
 access modes to the data needed by the codelet (e.g. ::STARPU_RW).
@@ -434,12 +434,12 @@ number of datas greater than \ref STARPU_NMAXBUFS (see \ref
 SettingTheDataHandlesForATask). When defining a codelet, one
 should either define this field or the field starpu_task::modes defined above.
 
-\var starpu_task::cl_arg
+\var void *starpu_task::cl_arg
 Optional pointer which is passed to the codelet through the second
 argument of the codelet implementation (e.g. starpu_codelet::cpu_func
 or starpu_codelet::cuda_func). The default value is <c>NULL</c>.
 
-\var starpu_task::cl_arg_size
+\var size_t starpu_task::cl_arg_size
 Optional field. For some specific drivers, the pointer
 starpu_task::cl_arg cannot not be directly given to the driver
 function. A buffer of size starpu_task::cl_arg_size needs to be
@@ -451,7 +451,7 @@ the buffer in local store (LS) instead. This field is ignored for CPU,
 CUDA and OpenCL codelets, where the starpu_task::cl_arg pointer is
 given as such.
 
-\var starpu_task::cl_arg_free
+\var unsigned starpu_task::cl_arg_free
 Optional field. In case starpu_task::cl_arg was allocated by the
 application through <c>malloc()</c>, setting starpu_task::cl_arg_free
 to 1 makes StarPU automatically call <c>free(cl_arg)</c> when
@@ -459,7 +459,7 @@ destroying the task. This saves the user from defining a callback just
 for that. This is mostly useful when targetting MIC or SCC, where the
 codelet does not execute in the same memory space as the main thread.
 
-\var starpu_task::callback_func
+\var void (*starpu_task::callback_func)(void *)
 Optional field, the default value is <c>NULL</c>. This is a function
 pointer of prototype <c>void (*f)(void *)</c> which specifies a
 possible callback. If this pointer is non-null, the callback function
@@ -468,18 +468,18 @@ depend on it might already be executing. The callback is passed the
 value contained in the starpu_task::callback_arg field. No callback is
 executed if the field is set to NULL.
 
-\var starpu_task::callback_arg (optional) (default: NULL)
+\var void *starpu_task::callback_arg (optional) (default: NULL)
 Optional field, the default value is <c>NULL</c>. This is the pointer
 passed to the callback function. This field is ignored if the field
 starpu_task::callback_func is set to <c>NULL</c>.
 
-\var starpu_task::callback_arg_free
+\var unsigned starpu_task::callback_arg_free
 Optional field. In case starpu_task::callback_arg was allocated by the
 application through <c>malloc()</c>, setting starpu_task::callback_arg_free
 to 1 makes StarPU automatically call <c>free(callback_arg)</c> when
 destroying the task.
 
-\var starpu_task::prologue_callback_func
+\var void (*starpu_task::prologue_callback_func)(void *)
 Optional field, the default value is <c>NULL</c>. This is a function
 pointer of prototype <c>void (*f)(void *)</c> which specifies a
 possible callback. 
@@ -489,40 +489,40 @@ before getting scheduled. The callback is passed the
 value contained in the starpu_task::prologue_callback_arg field. No callback is
 executed if the field is set to NULL.
 
-\var starpu_task::prologue_callback_arg (optional) (default: NULL)
+\var void *starpu_task::prologue_callback_arg (optional) (default: NULL)
 Optional field, the default value is <c>NULL</c>. This is the pointer
 passed to the prologue callback function. This field is ignored if the field
 starpu_task::prologue_callback_func is set to <c>NULL</c>.
 
-\var starpu_task::prologue_callback_arg_free
+\var unsigned starpu_task::prologue_callback_arg_free
 Optional field. In case starpu_task::prologue_callback_arg was allocated by the
 application through <c>malloc()</c>, setting starpu_task::prologue_callback_arg_free
 to 1 makes StarPU automatically call <c>free(prologue_callback_arg)</c> when
 destroying the task.
 
-\var starpu_task::use_tag
+\var unsigned starpu_task::use_tag
 Optional field, the default value is 0. If set, this flag indicates
 that the task should be associated with the tag contained in the
 starpu_task::tag_id field. Tag allow the application to synchronize
 with the task and to express task dependencies easily.
 
-\var starpu_task::tag_id
+\var starpu_tag_t starpu_task::tag_id
 This optional field contains the tag associated to the task if the
 field starpu_task::use_tag is set, it is ignored otherwise.
 
-\var starpu_task::sequential_consistency
+\var unsigned starpu_task::sequential_consistency
 If this flag is set (which is the default), sequential consistency is
 enforced for the data parameters of this task for which sequential
 consistency is enabled. Clearing this flag permits to disable
 sequential consistency for this task, even if data have it enabled.
 
-\var starpu_task::synchronous
+\var unsigned starpu_task::synchronous
 If this flag is set, the function starpu_task_submit() is blocking and
 returns only when the task has been executed (or if no worker is able
 to process the task). Otherwise, starpu_task_submit() returns
 immediately.
 
-\var starpu_task::priority
+\var int starpu_task::priority
 Optional field, the default value is ::STARPU_DEFAULT_PRIO. This field
 indicates a level of priority for the task. This is an integer value
 that must be set between the return values of the function
@@ -537,19 +537,19 @@ static task initialization. Scheduling strategies that take priorities
 into account can use this parameter to take better scheduling
 decisions, but the scheduling policy may also ignore it.
 
-\var starpu_task::execute_on_a_specific_worker
+\var unsigned starpu_task::execute_on_a_specific_worker
 Default value is 0. If this flag is set, StarPU will bypass the
 scheduler and directly affect this task to the worker specified by the
 field starpu_task::workerid.
 
-\var starpu_task::workerid
+\var unsigned starpu_task::workerid
 Optional field. If the field starpu_task::execute_on_a_specific_worker
 is set, this field indicates the identifier of the worker that should
 process this task (as returned by starpu_worker_get_id()). This field
 is ignored if the field starpu_task::execute_on_a_specific_worker is
 set to 0.
 
-\var starpu_task::workerorder
+\var unsigned starpu_task::workerorder
 Optional field. If the field starpu_task::execute_on_a_specific_worker is
 set, this field indicates the per-worker consecutive order in which tasks
 should be executed on the worker. Tasks will be executed in consecutive
@@ -557,17 +557,17 @@ starpu_task::workerorder values, thus ignoring the availability order or task
 priority. See \ref StaticScheduling for more details. This field is ignored if
 the field starpu_task::execute_on_a_specific_worker is set to 0.
 
-\var starpu_task::bundle
+\var starpu_task_bundle_t starpu_task::bundle
 Optional field. The bundle that includes this task. If no bundle is
 used, this should be NULL.
 
-\var starpu_task::detach
+\var unsigned starpu_task::detach
 Optional field, default value is 1. If this flag is set, it is not
 possible to synchronize with the task by the means of starpu_task_wait()
 later on. Internal data structures are only guaranteed to be freed
 once starpu_task_wait() is called if the flag is not set.
 
-\var starpu_task::destroy
+\var unsigned starpu_task::destroy
 Optional value. Default value is 0 for starpu_task_init(), and 1 for
 starpu_task_create(). If this flag is set, the task structure will
 automatically be freed, either after the execution of the callback if
@@ -579,64 +579,64 @@ undefined behaviour. The flag is set to 1 when the task is created by
 calling starpu_task_create(). Note that starpu_task_wait_for_all()
 will not free any task.
 
-\var starpu_task::regenerate
+\var unsigned starpu_task::regenerate
 Optional field. If this flag is set, the task will be re-submitted to
 StarPU once it has been executed. This flag must not be set if the
 flag starpu_task::destroy is set.
 
-\var starpu_task::status
+\var enum starpu_task_status starpu_task::status
 Optional field. Current state of the task.
 
-\var starpu_task::profiling_info
+\var struct starpu_profiling_task_info *starpu_task::profiling_info
 Optional field. Profiling information for the task.
 
-\var starpu_task::predicted
+\var double starpu_task::predicted
 Output field. Predicted duration of the task. This field is only set
 if the scheduling strategy uses performance models.
 
-\var starpu_task::predicted_transfer
+\var double starpu_task::predicted_transfer
 Optional field. Predicted data transfer duration for the task in
 microseconds. This field is only valid if the scheduling strategy uses
 performance models.
 
-\var starpu_task::prev
+\var struct starpu_task *starpu_task::prev
 \private
 A pointer to the previous task. This should only be used by StarPU.
 
-\var starpu_task::next
+\var struct starpu_task *starpu_task::next
 \private
 A pointer to the next task. This should only be used by StarPU.
 
-\var starpu_task::mf_skip
+\var unsigned int starpu_task::mf_skip
 \private
 This is only used for tasks that use multiformat handle. This should
 only be used by StarPU.
 
-\var starpu_task::flops
+\var double starpu_task::flops
 This can be set to the number of floating points operations that the
 task will have to achieve. This is useful for easily getting GFlops
 curves from the tool <c>starpu_perfmodel_plot</c>, and for the
 hypervisor load balancing.
 
-\var starpu_task::starpu_private
+\var void *starpu_task::starpu_private
 \private
 This is private to StarPU, do not modify. If the task is allocated by
 hand (without starpu_task_create()), this field should be set to NULL.
 
-\var starpu_task::magic
+\var int starpu_task::magic
 \private
 This field is set when initializing a task. The function
 starpu_task_submit() will fail if the field does not have the right
 value. This will hence avoid submitting tasks which have not been
 properly initialised.
 
-\var starpu_task::sched_ctx
+\var unsigned starpu_task::sched_ctx
 Scheduling context.
 
-\var starpu_task::hypervisor_tag
+\var int starpu_task::hypervisor_tag
 Helps the hypervisor monitor the execution of this task.
 
-\var starpu_task::scheduled
+\var unsigned starpu_task::scheduled
 Whether the scheduler has pushed the task on some queue
 
 \fn void starpu_task_init(struct starpu_task *task)

doc/doxygen/chapters/api/data_interfaces.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -55,98 +55,101 @@ 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.
 \ingroup API_Data_Interfaces
-\var starpu_data_copy_methods::can_copy
+\var int (*starpu_data_copy_methods::can_copy)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, unsigned handling_node)
 If defined, allows the interface to declare whether it supports transferring
 from \p src_interface on node \p src_node to \p dst_interface on node \p
 dst_node, run from node \p handling_node. If not defined, it is assumed that the
 interface supports all transfers.
-\var starpu_data_copy_methods::ram_to_ram
+
+\var int (*starpu_data_copy_methods::ram_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the \p
 src_node CPU node to the \p dst_interface interface on the \p dst_node
 CPU  node. Return 0 on success.
-\var starpu_data_copy_methods::ram_to_cuda
+
+\var int (*starpu_data_copy_methods::ram_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node CUDA
 node. Return 0 on success.
-\var starpu_data_copy_methods::ram_to_opencl
+
+\var int (*starpu_data_copy_methods::ram_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node
 OpenCL node. Return 0 on success.
 
-\var starpu_data_copy_methods::ram_to_mic
+\var int (*starpu_data_copy_methods::ram_to_mic)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node MIC
 node. Return 0 on success.
 
-\var starpu_data_copy_methods::cuda_to_ram
+\var int (*starpu_data_copy_methods::cuda_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CUDA node to the \p dst_interface interface on the \p dst_node
 CPU node. Return 0 on success.
-\var starpu_data_copy_methods::cuda_to_cuda
+\var int (*starpu_data_copy_methods::cuda_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CUDA node to the \p dst_interface interface on the \p dst_node CUDA
 node. Return 0 on success.
-\var starpu_data_copy_methods::cuda_to_opencl
+\var int (*starpu_data_copy_methods::cuda_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CUDA node to the \p dst_interface interface on the \p dst_node
 OpenCL node. Return 0 on success.
-\var starpu_data_copy_methods::opencl_to_ram
+\var int (*starpu_data_copy_methods::opencl_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node OpenCL node to the \p dst_interface interface on the \p dst_node
 CPU node. Return 0 on success.
-\var starpu_data_copy_methods::opencl_to_cuda
+\var int (*starpu_data_copy_methods::opencl_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node OpenCL node to the \p dst_interface interface on the \p dst_node
 CUDA node. Return 0 on success.
-\var starpu_data_copy_methods::opencl_to_opencl
+\var int (*starpu_data_copy_methods::opencl_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node OpenCL node to the \p dst_interface interface on the \p dst_node
 OpenCL node. Return 0 on success.
 
-\var starpu_data_copy_methods::mic_to_ram
+\var int (*starpu_data_copy_methods::mic_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node MIC node to the \p dst_interface interface on the \p dst_node CPU
 node. Return 0 on success.
 
-\var starpu_data_copy_methods::scc_src_to_sink
+\var int (*starpu_data_copy_methods::scc_src_to_sink)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node node to the \p dst_interface interface on the \p dst_node node.
 Must return 0 if the transfer was actually completed completely
 synchronously, or -EAGAIN if at least some transfers are still ongoing
 and should be awaited for by the core.
-\var starpu_data_copy_methods::scc_sink_to_src
+\var int (*starpu_data_copy_methods::scc_sink_to_src)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node node to the \p dst_interface interface on the \p dst_node node.
 Must return 0 if the transfer was actually completed completely
 synchronously, or -EAGAIN if at least some transfers are still ongoing
 and should be awaited for by the core.
-\var starpu_data_copy_methods::scc_sink_to_sink
+\var int (*starpu_data_copy_methods::scc_sink_to_sink)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node node to the \p dst_interface interface on the \p dst_node node.
 Must return 0 if the transfer was actually completed completely
 synchronously, or -EAGAIN if at least some transfers are still ongoing
 and should be awaited for by the core.
 
-\var starpu_data_copy_methods::ram_to_cuda_async
+\var int (*starpu_data_copy_methods::ram_to_cuda_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node CUDA
 node, using the given stream. Must return 0 if the transfer was
 actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the core.
-\var starpu_data_copy_methods::cuda_to_ram_async
+\var int (*starpu_data_copy_methods::cuda_to_ram_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CUDA node to the \p dst_interface interface on the \p dst_node CPU
 node, using the given stream. Must return 0 if the transfer was
 actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the core.
-\var starpu_data_copy_methods::cuda_to_cuda_async
+\var int (*starpu_data_copy_methods::cuda_to_cuda_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CUDA node to the \p dst_interface interface on the \p dst_node CUDA
 node, using the given stream. Must return 0 if the transfer was
 actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the core.
 
-\var starpu_data_copy_methods::ram_to_opencl_async
+\var int (*starpu_data_copy_methods::ram_to_opencl_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node
 OpenCL node, by recording in event, a pointer to a cl_event, the event
@@ -154,7 +157,7 @@ of the last submitted transfer. Must return 0 if the transfer was
 actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the
 core.
-\var starpu_data_copy_methods::opencl_to_ram_async
+\var int (*starpu_data_copy_methods::opencl_to_ram_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
 Define how to copy data from the \p src_interface interface on the
 \p src_node OpenCL node to the \p dst_interface interface on the \p dst_node
 CPU node, by recording in event, a pointer to a cl_event, the event of
@@ -162,7 +165,7 @@ the last submitted transfer. Must return 0 if the transfer was
 actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the
 core.
-\var starpu_data_copy_methods::opencl_to_opencl_async
+\var int (*starpu_data_copy_methods::opencl_to_opencl_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
 Define how to copy data from the \p src_interface interface on the
 \p src_node OpenCL node to the \p dst_interface interface on the \p dst_node
 OpenCL node, by recording in event, a pointer to a cl_event, the event
@@ -171,20 +174,20 @@ actually completed completely synchronously, or -EAGAIN if at least
 some transfers are still ongoing and should be awaited for by the
 core.
 
-\var starpu_data_copy_methods::ram_to_mic_async
+\var int (*starpu_data_copy_methods::ram_to_mic_async)(void *src_intreface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node CPU node to the \p dst_interface interface on the \p dst_node
 MIC node. Must return 0 if the transfer was actually completed
 completely synchronously, or -EAGAIN if at least some transfers are
 still ongoing and should be awaited for by the core.
-\var starpu_data_copy_methods::mic_to_ram_async
+\var int (*starpu_data_copy_methods::mic_to_ram_async)(void *src_intreface, unsigned src_node, void *dst_interface, unsigned dst_node)
 Define how to copy data from the \p src_interface interface on the
 \p src_node MIC node to the \p dst_interface interface on the \p dst_node
 CPU node. Must return 0 if the transfer was actually completed
 completely synchronously, or -EAGAIN if at least some transfers are
 still ongoing and should be awaited for by the core.
 
-\var starpu_data_copy_methods::any_to_any
+\var int (*starpu_data_copy_methods::any_to_any)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, void *async_data)
 Define how to copy data from the \p src_interface interface on the
 \p src_node node to the \p dst_interface interface on the \p dst_node node.
 This is meant to be implemented through the starpu_interface_copy()
@@ -392,15 +395,15 @@ after calling the data unpacking operation.
 \struct starpu_variable_interface
 Variable interface for a single data (not a vector, a matrix, a list, ...)
 \ingroup API_Data_Interfaces
-\var starpu_variable_interface::id
+\var enum starpu_data_interface_id starpu_variable_interface::id
 Identifier of the interface
-\var starpu_variable_interface::ptr
+\var uintptr_t starpu_variable_interface::ptr
 local pointer of the variable
-\var starpu_variable_interface::dev_handle
+\var uintptr_t starpu_variable_interface::dev_handle
 device handle of the variable.
-\var starpu_variable_interface::offset
+\var size_t starpu_variable_interface::offset
 offset in the variable
-\var starpu_variable_interface::elemsize
+\var size_t starpu_variable_interface::elemsize
 size of the variable
 
 \fn size_t starpu_variable_get_elemsize(starpu_data_handle_t handle)
@@ -436,17 +439,17 @@ be used with the device handle.
 \struct starpu_vector_interface
 Vector interface
 \ingroup API_Data_Interfaces
-\var starpu_vector_interface::id
+\var enum starpu_data_interface_id starpu_vector_interface::id
 Identifier of the interface
-\var starpu_vector_interface::ptr
+\var uintptr_t starpu_vector_interface::ptr
 local pointer of the vector
-\var starpu_vector_interface::dev_handle
+\var uintptr_t starpu_vector_interface::dev_handle
 device handle of the vector.
-\var starpu_vector_interface::offset
+\var size_t starpu_vector_interface::offset
 offset in the vector
-\var starpu_vector_interface::nx
+\var uint32_t starpu_vector_interface::nx
 number of elements on the x-axis of the vector
-\var starpu_vector_interface::elemsize
+\var size_t starpu_vector_interface::elemsize
 size of the elements of the vector
 
 \fn uint32_t starpu_vector_get_nx(starpu_data_handle_t handle)
@@ -501,22 +504,22 @@ Return the OpenMP slice base annotation of each element of the array designated
 \struct starpu_matrix_interface
 Matrix interface for dense matrices
 \ingroup API_Data_Interfaces
-\var starpu_matrix_interface::id
+\var enum starpu_data_interface_id starpu_matrix_interface::id
 Identifier of the interface
-\var starpu_matrix_interface::ptr
+\var uintptr_t starpu_matrix_interface::ptr
 local pointer of the matrix
-\var starpu_matrix_interface::dev_handle
+\var uintptr_t starpu_matrix_interface::dev_handle
 device handle of the matrix.
-\var starpu_matrix_interface::offset
+\var size_t starpu_matrix_interface::offset
 offset in the matrix
-\var starpu_matrix_interface::nx
+\var uint32_t starpu_matrix_interface::nx
 number of elements on the x-axis of the matrix
-\var starpu_matrix_interface::ny
+\var uint32_t starpu_matrix_interface::ny
 number of elements on the y-axis of the matrix
-\var starpu_matrix_interface::ld
+\var uint32_t 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
+\var size_t starpu_matrix_interface::elemsize
 size of the elements of the matrix
 
 \fn uint32_t starpu_matrix_get_nx(starpu_data_handle_t handle)
@@ -586,25 +589,25 @@ designated by \p interface.
 \struct starpu_block_interface
 Block interface for 3D dense blocks
 \ingroup API_Data_Interfaces
-\var starpu_block_interface::id
+\var enum starpu_data_interface_id starpu_block_interface::id
 identifier of the interface
-\var starpu_block_interface::ptr
+\var uintptr_t starpu_block_interface::ptr
 local pointer of the block
-\var starpu_block_interface::dev_handle
+\var uintptr_t starpu_block_interface::dev_handle
 device handle of the block.
-\var starpu_block_interface::offset
+\var size_t starpu_block_interface::offset
 offset in the block.
-\var starpu_block_interface::nx
+\var uint32_t starpu_block_interface::nx
 number of elements on the x-axis of the block.
-\var starpu_block_interface::ny
+\var uint32_t starpu_block_interface::ny
 number of elements on the y-axis of the block.
-\var starpu_block_interface::nz
+\var uint32_t starpu_block_interface::nz
 number of elements on the z-axis of the block.
-\var starpu_block_interface::ldy
+\var uint32_t starpu_block_interface::ldy
 number of elements between two lines
-\var starpu_block_interface::ldz
+\var uint32_t starpu_block_interface::ldz
 number of elements between two planes
-\var starpu_block_interface::elemsize
+\var size_t starpu_block_interface::elemsize
 size of the elements of the block.
 
 \fn uint32_t starpu_block_get_nx(starpu_data_handle_t handle)
@@ -694,25 +697,25 @@ Return the size of the elements of the block designated by
 BCSR interface for sparse matrices (blocked compressed sparse
 row representation)
 \ingroup API_Data_Interfaces
-\var starpu_bcsr_interface::id
+\var enum starpu_data_interface_id starpu_bcsr_interface::id
 Identifier of the interface
-\var starpu_bcsr_interface::nnz
+\var uint32_t starpu_bcsr_interface::nnz
 number of non-zero BLOCKS
-\var starpu_bcsr_interface::nrow
+\var uint32_t starpu_bcsr_interface::nrow
 number of rows (in terms of BLOCKS)
-\var starpu_bcsr_interface::nzval
+\var uintptr_t starpu_bcsr_interface::nzval
 non-zero values
-\var starpu_bcsr_interface::colind
+\var uint32_t *starpu_bcsr_interface::colind
 position of non-zero entried on the row
-\var starpu_bcsr_interface::rowptr
+\var uint32_t *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
+\var uint32_t starpu_bcsr_interface::r
 size of the blocks
-\var starpu_bcsr_interface::c
+\var uint32_t starpu_bcsr_interface::c
 size of the blocks
-\var starpu_bcsr_interface::elemsize;
+\var size_t starpu_bcsr_interface::elemsize;
 size of the elements of the matrix
 
 \fn uint32_t starpu_bcsr_get_nnz(starpu_data_handle_t handle)
@@ -807,21 +810,21 @@ matrix designated by \p interface, to be used with the device handles.
 \struct starpu_csr_interface
 CSR interface for sparse matrices (compressed sparse row representation)
 \ingroup API_Data_Interfaces
-\var starpu_csr_interface::id
+\var enum starpu_data_interface_id starpu_csr_interface::id
 Identifier of the interface
-\var starpu_csr_interface::nnz
+\var uint32_t starpu_csr_interface::nnz
 number of non-zero entries
-\var starpu_csr_interface::nrow
+\var uint32_t starpu_csr_interface::nrow
 number of rows
-\var starpu_csr_interface::nzval
+\var uintptr_t starpu_csr_interface::nzval
 non-zero values
-\var starpu_csr_interface::colind
+\var uint32_t *starpu_csr_interface::colind
 position of non-zero entries on the row
-\var starpu_csr_interface::rowptr
+\var uint32_t *starpu_csr_interface::rowptr
 index (in nzval) of the first entry of the row
-\var starpu_csr_interface::firstentry
+\var uint32_t starpu_csr_interface::firstentry
 k for k-based indexing (0 or 1 usually). also useful when partitionning the matrix.
-\var starpu_csr_interface::elemsize
+\var size_t starpu_csr_interface::elemsize
 size of the elements of the matrix
 
 \fn uint32_t starpu_csr_get_nnz(starpu_data_handle_t handle)
@@ -923,21 +926,21 @@ designated by \p interface.
 \struct starpu_coo_interface
 COO Matrices
 \ingroup API_Data_Interfaces
-\var starpu_coo_interface::id
+\var enum starpu_data_interface_id starpu_coo_interface::id
 identifier of the interface
-\var starpu_coo_interface::columns
+\var uint32_t  *starpu_coo_interface::columns
 column array of the matrix
-\var starpu_coo_interface::rows
+\var uint32_t  *starpu_coo_interface::rows
 row array of the matrix
-\var starpu_coo_interface::values
+\var uintptr_t starpu_coo_interface::values
 values of the matrix
-\var starpu_coo_interface::nx
+\var uint32_t  starpu_coo_interface::nx
 number of elements on the x-axis of the matrix
-\var starpu_coo_interface::ny
+\var uint32_t  starpu_coo_interface::ny
 number of elements on the y-axis of the matrix
-\var starpu_coo_interface::n_values
+\var uint32_t  starpu_coo_interface::n_values
 number of values registered in the matrix
-\var starpu_coo_interface::elemsize
+\var size_t starpu_coo_interface::elemsize
 size of the elements of the matrix
 
 \def STARPU_COO_GET_COLUMNS(interface)

doc/doxygen/chapters/api/data_partition.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -12,22 +12,22 @@
 The filter structure describes a data partitioning operation, to be
 given to the starpu_data_partition() function.
 \ingroup API_Data_Partition
-\var starpu_data_filter::filter_func
+\var void (*starpu_data_filter::filter_func)(void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts)
 This function fills the child_interface structure with interface
 information for the id-th child of the parent father_interface (among
 nparts).
-\var starpu_data_filter::nchildren
+\var unsigned starpu_data_filter::nchildren
 This is the number of parts to partition the data into.
-\var starpu_data_filter::get_nchildren
+\var unsigned (*starpu_data_filter::get_nchildren)(struct starpu_data_filter *, starpu_data_handle_t initial_handle)
 This returns the number of children. This can be used instead of
 nchildren when the number of children depends on the actual data (e.g.
 the number of blocks in a sparse matrix).
-\var starpu_data_filter::get_child_ops
+\var struct starpu_data_interface_ops *(*starpu_data_filter::get_child_ops)(struct starpu_data_filter *, unsigned id)
 In case the resulting children use a different data interface, this
 function returns which interface is used by child number id.
-\var starpu_data_filter::filter_arg
+\var unsigned starpu_data_filter::filter_arg
 Allow to define an additional parameter for the filter function.
-\var starpu_data_filter::filter_arg_ptr
+\var void *starpu_data_filter::filter_arg_ptr
 Allow to define an additional pointer parameter for the filter
 function, such as the sizes of the different parts.
 

doc/doxygen/chapters/api/fxt_support.doxy

@@ -11,47 +11,47 @@
 \struct starpu_fxt_codelet_event
 todo
 \ingroup API_FxT_Support
-\var starpu_fxt_codelet_event::symbol[256
+\var char starpu_fxt_codelet_event::symbol[256]
 name of the codelet
-\var starpu_fxt_codelet_event::workerid
-\var starpu_fxt_codelet_event::archtype
-\var starpu_fxt_codelet_event::hash
-\var starpu_fxt_codelet_event::size
-\var starpu_fxt_codelet_event::time
+\var int starpu_fxt_codelet_event::workerid
+\var char starpu_fxt_codelet_event::perfmodel_archname[256]
+\var uint32_t starpu_fxt_codelet_event::hash
+\var size_t starpu_fxt_codelet_event::size
+\var float starpu_fxt_codelet_event::time
 
 \struct starpu_fxt_options
 todo
 \ingroup API_FxT_Support
-\var starpu_fxt_options::per_task_colour
-\var starpu_fxt_options::no_counter
-\var starpu_fxt_options::no_bus
-\var starpu_fxt_options::ninputfiles
-\var starpu_fxt_options::filenames
-\var starpu_fxt_options::out_paje_path
-\var starpu_fxt_options::distrib_time_path
-\var starpu_fxt_options::activity_path
-\var starpu_fxt_options::dag_path
+\var unsigned starpu_fxt_options::per_task_colour
+\var unsigned starpu_fxt_options::no_counter
+\var starpu_unsigned fxt_options::no_bus
+\var unsigned starpu_fxt_options::ninputfiles
+\var char *starpu_fxt_options::filenames[STARPU_FXT_MAX_FILES]
+\var char *starpu_fxt_options::out_paje_path
+\var char *starpu_fxt_options::distrib_time_path
+\var char *starpu_fxt_options::activity_path
+\var char *starpu_fxt_options::dag_path
 
-\var starpu_fxt_options::file_prefix
+\var char *starpu_fxt_options::file_prefix
 In case we are going to gather multiple traces (e.g in the case of MPI
 processes), we may need to prefix the name of the containers.
-\var starpu_fxt_options::file_offset
+\var uint64_t starpu_fxt_options::file_offset
 In case we are going to gather multiple traces (e.g in the case of MPI
 processes), we may need to prefix the name of the containers.
-\var starpu_fxt_options::file_rank
+\var int starpu_fxt_options::file_rank
 In case we are going to gather multiple traces (e.g in the case of MPI
 processes), we may need to prefix the name of the containers.
 
-\var starpu_fxt_options::worker_names
+\var char starpu_fxt_options::worker_names[STARPU_NMAXWORKERS][256]
 Output parameters
-\var starpu_fxt_options::worker_archtypes
+\var struct starpu_perfmodel_arch starpu_fxt_options::worker_archtypes[STARPU_NMAXWORKERS]
 Output parameters
-\var starpu_fxt_options::nworkers
+\var int starpu_fxt_options::nworkers
 Output parameters
 
-\var starpu_fxt_options::dumped_codelets
+\var struct starpu_fxt_codelet_event **starpu_fxt_options::dumped_codelets
 In case we want to dump the list of codelets to an external tool
-\var starpu_fxt_options::dumped_codelets_count
+\var long starpu_fxt_options::dumped_codelets_count
 In case we want to dump the list of codelets to an external tool
 
 \fn void starpu_fxt_options_init(struct starpu_fxt_options *options)

doc/doxygen/chapters/api/initialization.doxy

@@ -11,16 +11,12 @@
 \struct starpu_driver
 structure for a driver
 \ingroup API_Initialization_and_Termination
-\var starpu_driver::type
+\var enum starpu_worker_archtype starpu_driver::type
 The type of the driver. Only ::STARPU_CPU_WORKER,
 ::STARPU_CUDA_WORKER and ::STARPU_OPENCL_WORKER are currently supported.
-\var starpu_driver::id
+\var union starpu_driver::id
 The identifier of the driver.
 
-\struct starpu_vector_interface
-vector interface for contiguous (non-strided) buffers
-\ingroup API_Initialization_and_Termination
-
 \struct starpu_conf
 \ingroup API_Initialization_and_Termination
 This structure is passed to the starpu_init() function in order to
@@ -28,96 +24,94 @@ configure StarPU. It has to be initialized with starpu_conf_init().
 When the default value is used, StarPU automatically selects the
 number of processing units and takes the default scheduling policy.
 The environment variables overwrite the equivalent parameters.
-\var starpu_conf::magic
+\var int starpu_conf::magic
 \private
 Will be initialized by starpu_conf_init(). Should not be set by hand.
-\var starpu_conf::sched_policy_name
+\var const char*starpu_conf::sched_policy_name
 This is the name of the scheduling policy. This can also be specified
 with the environment variable \ref STARPU_SCHED. (default = NULL).
-\var starpu_conf::sched_policy
+\var struct starpu_sched_policy *starpu_conf::sched_policy
 This is the definition of the scheduling policy. This field is ignored
 if starpu_conf::sched_policy_name is set. (default = NULL)
-\var starpu_conf::ncpus
+\var int starpu_conf::ncpus
 This is the number of CPU cores that StarPU can use. This can also be
 specified with the environment variable \ref STARPU_NCPU . (default = -1)
-\var starpu_conf::ncuda
+\var int starpu_conf::ncuda
 This is the number of CUDA devices that StarPU can use. This can also
 be specified with the environment variable \ref STARPU_NCUDA. (default =
 -1)
-\var starpu_conf::nopencl
+\var int starpu_conf::nopencl
 This is the number of OpenCL devices that StarPU can use. This can
 also be specified with the environment variable \ref STARPU_NOPENCL.
 (default = -1)
-\var starpu_conf::nmic
+\var int starpu_conf::nmic
 This is the number of MIC devices that StarPU can use. This can also
 be specified with the environment variable \ref STARPU_NMIC.
 (default = -1)
-\var starpu_conf::nscc
+\var int starpu_conf::nscc
 This is the number of SCC devices that StarPU can use. This can also
 be specified with the environment variable \ref STARPU_NSCC.
 (default = -1)
 
-\var starpu_conf::use_explicit_workers_bindid
+\var unsigned 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
 selects where to bind the different workers. This can also be
 specified with the environment variable \ref STARPU_WORKERS_CPUID. (default = 0)
-\var starpu_conf::workers_bindid
+\var unsigned starpu_conf::workers_bindid[STARPU_NMAXWORKERS]
 If the starpu_conf::use_explicit_workers_bindid flag is set, this
 array indicates where to bind the different workers. The i-th entry of
 the starpu_conf::workers_bindid indicates the logical identifier of
 the processor which should execute the i-th worker. Note that the
 logical ordering of the CPUs is either determined by the OS, or
 provided by the hwloc library in case it is available.
-\var starpu_conf::use_explicit_workers_cuda_gpuid
+\var unsigned starpu_conf::use_explicit_workers_cuda_gpuid
 If this flag is set, the CUDA workers will be attached to the CUDA
 devices specified in the starpu_conf::workers_cuda_gpuid array.
 Otherwise, StarPU affects the CUDA devices in a round-robin fashion.
 This can also be specified with the environment variable \ref
 STARPU_WORKERS_CUDAID. (default = 0)
-\var starpu_conf::workers_cuda_gpuid
+\var unsigned starpu_conf::workers_cuda_gpuid[STARPU_NMAXWORKERS]
 If the starpu_conf::use_explicit_workers_cuda_gpuid flag is set, this
 array contains the logical identifiers of the CUDA devices (as used by
 cudaGetDevice()).
-\var starpu_conf::use_explicit_workers_opencl_gpuid
+\var unsigned starpu_conf::use_explicit_workers_opencl_gpuid
 If this flag is set, the OpenCL workers will be attached to the OpenCL
 devices specified in the starpu_conf::workers_opencl_gpuid array.
 Otherwise, StarPU affects the OpenCL devices in a round-robin fashion.
 This can also be specified with the environment variable \ref
 STARPU_WORKERS_OPENCLID. (default = 0)
-\var starpu_conf::workers_opencl_gpuid
+\var unsigned starpu_conf::workers_opencl_gpuid[STARPU_NMAXWORKERS]
 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
+\var unsigned 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.
 Otherwise, StarPU affects the MIC devices in a round-robin fashion.
 This can also be specified with the environment variable \ref
 STARPU_WORKERS_MICID.
 (default = 0)
-\var starpu_conf::workers_mic_deviceid
+\var unsigned starpu_conf::workers_mic_deviceid[STARPU_NMAXWORKERS]
 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
+\var unsigned 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
+\var unsigned starpu_conf::workers_scc_deviceid[STARPU_NMAXWORKERS]
 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.
 Otherwise, StarPU affects the SCC devices in a round-robin fashion.
 This can also be specified with the environment variable \ref
 STARPU_WORKERS_SCCID.
 
-\var starpu_conf::bus_calibrate
+\var int 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
 specified with the environment variable \ref STARPU_BUS_CALIBRATE. (default
 = 0)
-\var starpu_conf::calibrate
+\var int starpu_conf::calibrate
 If this flag is set, StarPU will calibrate the performance models when
 executing tasks. If this value is equal to <c>-1</c>, the default
 value is used. If the value is equal to <c>1</c>, it will force
@@ -125,7 +119,7 @@ continuing calibration. If the value is equal to <c>2</c>, the
 existing performance models will be overwritten. This can also be
 specified with the environment variable \ref STARPU_CALIBRATE. (default =
 0)
-\var starpu_conf::single_combined_worker
+\var int starpu_conf::single_combined_worker
 By default, StarPU executes parallel tasks
 concurrently. Some parallel libraries (e.g. most OpenMP
 implementations) however do not support concurrent calls to
@@ -138,13 +132,13 @@ most efficient ones. This can also be specified with the environment
 variable \ref STARPU_SINGLE_COMBINED_WORKER.
 (default = 0)
 
-\var starpu_conf::mic_sink_program_path
+\var char *starpu_conf::mic_sink_program_path
 Path to the kernel to execute on the MIC device, compiled for MIC
 architecture. When set to NULL, StarPU automatically looks next to the
 host program location.
 (default = NULL)
 
-\var starpu_conf::disable_asynchronous_copy
+\var int starpu_conf::disable_asynchronous_copy
 This flag should be set to 1 to disable
 asynchronous copies between CPUs and all accelerators. This
 can also be specified with the environment variable \ref
@@ -155,7 +149,7 @@ therefore necessary to disable asynchronous data transfers.
 This can also be specified at compilation time by giving to
 the configure script the option
 \ref disable-asynchronous-copy "--disable-asynchronous-copy". (default = 0)
-\var starpu_conf::disable_asynchronous_cuda_copy
+\var int starpu_conf::disable_asynchronous_cuda_copy
 This flag should be set to 1 to disable
 asynchronous copies between CPUs and CUDA accelerators.
 This can also be specified with the environment variable
@@ -163,7 +157,7 @@ This can also be specified with the environment variable
 This can also be specified at compilation time by giving to
 the configure script the option
 \ref disable-asynchronous-cuda-copy "--disable-asynchronous-cuda-copy". (default = 0)
-\var starpu_conf::disable_asynchronous_opencl_copy
+\var int starpu_conf::disable_asynchronous_opencl_copy
 This flag should be set to 1 to disable
 asynchronous copies between CPUs and OpenCL accelerators.
 This can also be specified with the environment
@@ -175,8 +169,7 @@ asynchronous data transfers. This can also be specified at
 compilation time by giving to the configure script the
 option \ref disable-asynchronous-opencl-copy "--disable-asynchronous-opencl-copy".
 (default = 0)
-
-\var starpu_conf::disable_asynchronous_mic_copy
+\var int starpu_conf::disable_asynchronous_mic_copy
 This flag should be set to 1 to disable asynchronous copies between
 CPUs and MIC accelerators. This can also be specified with the
 environment variable \ref STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY.
@@ -184,19 +177,21 @@ This can also be specified at compilation time by giving to the
 configure script the option \ref disable-asynchronous-mic-copy "--disable-asynchronous-mic-copy".
 (default = 0).
 
-\var starpu_conf::cuda_opengl_interoperability
+\var unsigned *starpu_conf::cuda_opengl_interoperability
 Enable CUDA/OpenGL interoperation on these CUDA
 devices. This can be set to an array of CUDA device
 identifiers for which cudaGLSetGLDevice() should be called
 instead of cudaSetDevice(). Its size is specified by the
 starpu_conf::n_cuda_opengl_interoperability field below
 (default = NULL)
-\var starpu_conf::n_cuda_opengl_interoperability
-\var starpu_conf::not_launched_drivers
+\var unsigned starpu_conf::n_cuda_opengl_interoperability
+todo
+
+\var struct starpu_driver *starpu_conf::not_launched_drivers
 Array of drivers that should not be launched by
 StarPU. The application will run in one of its own
 threads. (default = NULL)
-\var starpu_conf::n_not_launched_drivers
+\var unsigned starpu_conf::n_not_launched_drivers
 The number of StarPU drivers that should not be
 launched by StarPU. (default = 0)
 \var starpu_conf::trace_buffer_size

doc/doxygen/chapters/api/modularized_scheduler.doxy

@@ -45,13 +45,13 @@ like component->push_task(component,task)
      this member is set with :
      component->workers UNION tree->workers UNION
      component->child[i]->workers_in_ctx iff exist x such as component->children[i]->parents[x] == component
-\var starpu_sched_component::data
+\var void *starpu_sched_component::data
      private data
-\var starpu_sched_component::nchildren
+\var int starpu_sched_component::nchildren
      the number of compoments's children
-\var starpu_sched_component::children
+\var struct starpu_sched_component **starpu_sched_component::children
      the vector of component's children
-\var starpu_sched_component::nparents
+\var int starpu_sched_component::nparents
      the numbers of component's parents
 \var struct starpu_sched_component **starpu_sched_component::parents
      the vector of component's parents

doc/doxygen/chapters/api/multiformat_data_interface.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -11,37 +11,37 @@
 \struct starpu_multiformat_data_interface_ops
 \ingroup API_Multiformat_Data_Interface
 The different fields are:
-\var starpu_multiformat_data_interface_ops::cpu_elemsize
+\var size_t starpu_multiformat_data_interface_ops::cpu_elemsize
         the size of each element on CPUs
-\var starpu_multiformat_data_interface_ops::opencl_elemsize
+\var size_t starpu_multiformat_data_interface_ops::opencl_elemsize
         the size of each element on OpenCL devices
-\var starpu_multiformat_data_interface_ops::cpu_to_opencl_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::cpu_to_opencl_cl
         pointer to a codelet which converts from CPU to OpenCL
-\var starpu_multiformat_data_interface_ops::opencl_to_cpu_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::opencl_to_cpu_cl
         pointer to a codelet which converts from OpenCL to CPU
-\var starpu_multiformat_data_interface_ops::cuda_elemsize
+\var size_t starpu_multiformat_data_interface_ops::cuda_elemsize
         the size of each element on CUDA devices
-\var starpu_multiformat_data_interface_ops::cpu_to_cuda_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::cpu_to_cuda_cl
         pointer to a codelet which converts from CPU to CUDA
-\var starpu_multiformat_data_interface_ops::cuda_to_cpu_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::cuda_to_cpu_cl
         pointer to a codelet which converts from CUDA to CPU
-\var starpu_multiformat_data_interface_ops::mic_elemsize
+\var size_t starpu_multiformat_data_interface_ops::mic_elemsize
         the size of each element on MIC devices
-\var starpu_multiformat_data_interface_ops::cpu_to_mic_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::cpu_to_mic_cl
         pointer to a codelet which converts from CPU to MIC
-\var starpu_multiformat_data_interface_ops::mic_to_cpu_cl
+\var struct starpu_codelet *starpu_multiformat_data_interface_ops::mic_to_cpu_cl
         pointer to a codelet which converts from MIC to CPU
 
 \struct starpu_multiformat_interface
 todo
 \ingroup API_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
+\var enum starpu_data_interface_id starpu_multiformat_interface::id
+\var void *starpu_multiformat_interface::cpu_ptr
+\var void *starpu_multiformat_interface::cuda_ptr
+\var void *starpu_multiformat_interface::opencl_ptr
+\var void *starpu_multiformat_interface::mic_ptr
+\var uint32_t starpu_multiformat_interface::nx
+\var struct starpu_multiformat_data_interface_ops *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 API_Multiformat_Data_Interface

doc/doxygen/chapters/api/opencl_extensions.doxy

@@ -28,7 +28,7 @@ applications provided with StarPU have been installed.
 \ingroup API_OpenCL_Extensions
 Stores the OpenCL programs as compiled for the different OpenCL
 devices.
-\var starpu_opencl_program::programs
+\var cl_program starpu_opencl_program::programs[STARPU_MAXOPENCLDEVS]
 Stores each program for each OpenCL device.
 
 @name Writing OpenCL kernels

doc/doxygen/chapters/api/openmp_runtime_support.doxy

@@ -111,34 +111,34 @@ Set of attributes used for creating a new parallel region.
 
 \sa starpu_omp_parallel_region()
 
-\var starpu_omp_parallel_region_attr::cl
+\var struct starpu_codelet starpu_omp_parallel_region_attr::cl
 
 Is a ::starpu_codelet (\ref API_Codelet_And_Tasks) to use for the parallel region
 implicit tasks. The codelet must provide a CPU implementation function.
 
-\var starpu_omp_parallel_region_attr::handles
+\var starpu_data_handle_t *starpu_omp_parallel_region_attr::handles
 
 Is an array of zero or more ::starpu_data_handle_t data handle to be passed to
 the parallel region implicit tasks.
 
-\var starpu_omp_parallel_region_attr::cl_arg
+\var void *starpu_omp_parallel_region_attr::cl_arg
 
 Is an optional pointer to an inline argument to be passed to the region implicit tasks.
 
-\var starpu_omp_parallel_region_attr::cl_arg_size
+\var size_t starpu_omp_parallel_region_attr::cl_arg_size
 
 Is the size of the optional inline argument to be passed to the region implicit tasks, or 0 if unused.
 
-\var starpu_omp_parallel_region_attr::cl_arg_free
+\var unsigned starpu_omp_parallel_region_attr::cl_arg_free
 
 Is a boolean indicating whether the optional inline argument should be automatically freed (true), or not (false).
 
-\var starpu_omp_parallel_region_attr::if_clause
+\var int starpu_omp_parallel_region_attr::if_clause
 
 Is a boolean indicating whether the \b if clause of the corresponding <c>pragma
 omp parallel</c> is true or false.
 
-\var starpu_omp_parallel_region_attr::num_threads
+\var int starpu_omp_parallel_region_attr::num_threads
 
 Is an integer indicating the requested number of threads in the team of the
 newly created parallel region, or 0 to let the runtime choose the number of
@@ -152,47 +152,47 @@ Set of attributes used for creating a new task region.
 
 \sa starpu_omp_task_region()
 
-\var starpu_omp_task_region_attr::cl
+\var struct starpu_codelet starpu_omp_task_region_attr::cl
 
 Is a ::starpu_codelet (\ref API_Codelet_And_Tasks) to use for the task region
 explicit task. The codelet must provide a CPU implementation function or an
 accelerator implementation for offloaded target regions.
 
-\var starpu_omp_task_region_attr::handles
+\var starpu_data_handle_t *starpu_omp_task_region_attr::handles
 
 Is an array of zero or more ::starpu_data_handle_t data handle to be passed to
 the task region explicit tasks.
 
-\var starpu_omp_task_region_attr::cl_arg
+\var void *starpu_omp_task_region_attr::cl_arg
 
 Is an optional pointer to an inline argument to be passed to the region implicit tasks.
 
-\var starpu_omp_task_region_attr::cl_arg_size
+\var size_t starpu_omp_task_region_attr::cl_arg_size
 
 Is the size of the optional inline argument to be passed to the region implicit
 tasks, or 0 if unused.
 
-\var starpu_omp_task_region_attr::cl_arg_free
+\var unsigned starpu_omp_task_region_attr::cl_arg_free
 
 Is a boolean indicating whether the optional inline argument should be
 automatically freed (true), or not (false).
 
-\var starpu_omp_task_region_attr::if_clause
+\var int starpu_omp_task_region_attr::if_clause
 
 Is a boolean indicating whether the \b if clause of the corresponding <c>pragma
 omp task</c> is true or false.
 
-\var starpu_omp_task_region_attr::final_clause
+\var int starpu_omp_task_region_attr::final_clause
 
 Is a boolean indicating whether the \b final clause of the corresponding <c>pragma
 omp task</c> is true or false.
 
-\var starpu_omp_task_region_attr::untied_clause
+\var int starpu_omp_task_region_attr::untied_clause
 
 Is a boolean indicating whether the \b untied clause of the corresponding <c>pragma
 omp task</c> is true or false.
 
-\var starpu_omp_task_region_attr::mergeable_clause
+\var int starpu_omp_task_region_attr::mergeable_clause
 
 Is a boolean indicating whether the \b mergeable clause of the corresponding <c>pragma
 omp task</c> is true or false.

doc/doxygen/chapters/api/performance_model.doxy

@@ -74,7 +74,7 @@ whole structure to zero, either by using explicit memset, or by
 letting the compiler implicitly do it in e.g. static storage case. If
 not provided, other fields have to be zero.
 \ingroup API_Performance_Model
-\var starpu_perfmodel::type
+\var enum starpu_perfmodel_type starpu_perfmodel::type
 is the type of performance model
 <ul>
 <li>::STARPU_HISTORY_BASED, ::STARPU_REGRESSION_BASED,
@@ -90,90 +90,85 @@ CPU, timing on other archs will be determined by multiplying by an
 arch-specific factor.
 </li>
 </ul>
-\var starpu_perfmodel::symbol
+\var const char *starpu_perfmodel::symbol
 is the symbol name for the performance model, which will be used as
 file name to store the model. It must be set otherwise the model will
 be ignored.
-This field is deprecated. Use instead the field starpu_perfmodel::cost_function field.
-\var starpu_perfmodel::cost_function
+\var double (*starpu_perfmodel::cost_function)(struct starpu_task *, unsigned nimpl)
 Used by ::STARPU_COMMON: takes a task and implementation number, and
 must return a task duration estimation in micro-seconds.
-\var starpu_perfmodel::size_base
+\var size_t (*starpu_perfmodel::size_base)(struct starpu_task *, unsigned nimpl)
 Used by ::STARPU_HISTORY_BASED, ::STARPU_REGRESSION_BASED and
 ::STARPU_NL_REGRESSION_BASED. If not NULL, takes a task and
 implementation number, and returns the size to be used as index to distinguish
 histories and as a base for regressions.
-\var starpu_perfmodel::footprint
+\var uint32_t (*starpu_perfmodel::footprint)(struct starpu_task *)
 Used by ::STARPU_HISTORY_BASED. If not NULL, takes a task and returns the
 footprint to be used as index to distinguish histories. The default is to use
 the starpu_task_data_footprint function.
-\var starpu_perfmodel::per_arch
-Used by ::STARPU_PER_ARCH: array of structures starpu_per_arch_perfmodel
-\var starpu_perfmodel::is_loaded
+\var unsigned starpu_perfmodel::is_loaded
 \private
 Whether the performance model is already loaded from the disk.
-\var starpu_perfmodel::benchmarking
+\var unsigned starpu_perfmodel::benchmarking
 \private
-Whether the performance model is still being calibrated.
-\var starpu_perfmodel::model_rwlock
+\var unsigned starpu_perfmodel::is_init
+todo
+\var starpu_perfmodel_state_t starpu_perfmodel::state
 \private
-Lock to protect concurrency between loading from disk (W), updating
-the values (W), and making a performance estimation (R).
+
 
 \struct starpu_perfmodel_regression_model
 ...
 \ingroup API_Performance_Model
-\var starpu_perfmodel_regression_model::sumlny
+\var double starpu_perfmodel_regression_model::sumlny
 sum of ln(measured)
-\var starpu_perfmodel_regression_model::sumlnx
+\var double starpu_perfmodel_regression_model::sumlnx
 sum of ln(size)
-\var starpu_perfmodel_regression_model::sumlnx2
+\var double starpu_perfmodel_regression_model::sumlnx2
 sum of ln(size)^2
-\var starpu_perfmodel_regression_model::minx
+\var unsigned long starpu_perfmodel_regression_model::minx
 minimum size
-\var starpu_perfmodel_regression_model::maxx
+\var unsigned long starpu_perfmodel_regression_model::maxx
 maximum size
-\var starpu_perfmodel_regression_model::sumlnxlny
+\var double starpu_perfmodel_regression_model::sumlnxlny
 sum of ln(size)*ln(measured)
-\var starpu_perfmodel_regression_model::alpha
+\var double starpu_perfmodel_regression_model::alpha
 estimated = alpha * size ^ beta
-\var starpu_perfmodel_regression_model::beta
+\var double starpu_perfmodel_regression_model::beta
 estimated = alpha * size ^ beta
-\var starpu_perfmodel_regression_model::valid
+\var unsigned starpu_perfmodel_regression_model::valid
 whether the linear regression model is valid (i.e. enough measures)
-\var starpu_perfmodel_regression_model::a
+\var double starpu_perfmodel_regression_model::a
 estimated = a size ^b + c
-\var starpu_perfmodel_regression_model::b
+\var double starpu_perfmodel_regression_model::b
 estimated = a size ^b + c
-\var starpu_perfmodel_regression_model::c
+\var double starpu_perfmodel_regression_model::c
 estimated = a size ^b + c
-\var starpu_perfmodel_regression_model::nl_valid
+\var unsigned starpu_perfmodel_regression_model::nl_valid
 whether the non-linear regression model is valid (i.e. enough measures)
-\var starpu_perfmodel_regression_model::nsample
+\var unsigned starpu_perfmodel_regression_model::nsample
 number of sample values for non-linear regression
 
 \struct starpu_perfmodel_per_arch
 contains information about the performance model of a given
 arch.
 \ingroup API_Performance_Model
-This field is deprecated. Use instead the field
-starpu_perfmodel_per_arch::cost_function.
-\var starpu_perfmodel_per_arch::cost_function
+\var starpu_perfmodel_per_arch_cost_function starpu_perfmodel_per_arch::cost_function
 Used by ::STARPU_PER_ARCH, must point to functions which take a task,
 the target arch and implementation number (as mere conveniency, since
 the array is already indexed by these), and must return a task
 duration estimation in micro-seconds.
-\var starpu_perfmodel_per_arch::size_base
+\var starpu_perfmodel_per_arch_size_base starpu_perfmodel_per_arch::size_base
 Same as in structure starpu_perfmodel, but per-arch, in case it
 depends on the architecture-specific implementation.
-\var starpu_perfmodel_per_arch::history
+\var struct starpu_perfmodel_history_table *starpu_perfmodel_per_arch::history
 \private
 The history of performance measurements.
-\var starpu_perfmodel_per_arch::list
+\var struct starpu_perfmodel_history_list *starpu_perfmodel_per_arch::list
 \private
 Used by ::STARPU_HISTORY_BASED and ::STARPU_NL_REGRESSION_BASED,
 records all execution history measures.
-\var starpu_perfmodel_per_arch::regression
+\var struct starpu_perfmodel_regression_model starpu_perfmodel_per_arch::regression
 \private
 Used by ::STARPU_REGRESSION_BASED and
 ::STARPU_NL_REGRESSION_BASED, contains the estimated factors of the
@@ -182,29 +177,29 @@ regression.
 \struct starpu_perfmodel_history_list
 todo
 \ingroup API_Performance_Model
-\var starpu_perfmodel_history_list::next
+\var struct starpu_perfmodel_history_list *starpu_perfmodel_history_list::next
 todo
-\var starpu_perfmodel_history_list::entry
+\var struct starpu_perfmodel_history_entry *starpu_perfmodel_history_list::entry
 todo
 
 \struct starpu_perfmodel_history_entry
 todo
 \ingroup API_Performance_Model
-\var starpu_perfmodel_history_entry::mean
+\var double starpu_perfmodel_history_entry::mean
 mean_n = 1/n sum
-\var starpu_perfmodel_history_entry::deviation
+\var double starpu_perfmodel_history_entry::deviation
 n dev_n = sum2 - 1/n (sum)^2
-\var starpu_perfmodel_history_entry::sum
+\var double starpu_perfmodel_history_entry::sum
 sum of samples (in µs)
-\var starpu_perfmodel_history_entry::sum2
+\var double starpu_perfmodel_history_entry::sum2
 sum of samples^2
-\var starpu_perfmodel_history_entry::nsample
+\var unsigned starpu_perfmodel_history_entry::nsample
 number of samples
-\var starpu_perfmodel_history_entry::footprint
+\var uint32_t starpu_perfmodel_history_entry::footprint
 data footprint
-\var starpu_perfmodel_history_entry::size
+\var size_t starpu_perfmodel_history_entry::size
 in bytes
-\var starpu_perfmodel_history_entry::flops
+\var double starpu_perfmodel_history_entry::flops
 Provided by the application
 
 \fn void starpu_perfmodel_init(FILE *f, struct starpu_perfmodel *model)

doc/doxygen/chapters/api/profiling.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -13,89 +13,89 @@
 This structure contains information about the execution of a
 task. It is accessible from the field starpu_task::profiling_info if
 profiling was enabled.
-\var starpu_profiling_task_info::submit_time
+\var struct timespec starpu_profiling_task_info::submit_time
 Date of task submission (relative to the initialization of StarPU).
 
-\var starpu_profiling_task_info::push_start_time
+\var struct timespec starpu_profiling_task_info::push_start_time
 Time when the task was submitted to the scheduler.
 
-\var starpu_profiling_task_info::push_end_time
+\var struct timespec starpu_profiling_task_info::push_end_time
 Time when the scheduler finished with the task submission.
 
-\var starpu_profiling_task_info::pop_start_time
+\var struct timespec starpu_profiling_task_info::pop_start_time
 Time when the scheduler started to be requested for a task, and eventually gave that task.
 
-\var starpu_profiling_task_info::pop_end_time
+\var struct timespec starpu_profiling_task_info::pop_end_time
 Time when the scheduler finished providing the task for execution.
 
-\var starpu_profiling_task_info::acquire_data_start_time
+\var struct timespec starpu_profiling_task_info::acquire_data_start_time
 Time when the worker started fetching input data.
 
-\var starpu_profiling_task_info::acquire_data_end_time
+\var struct timespec starpu_profiling_task_info::acquire_data_end_time
 Time when the worker finished fetching input data.
 
-\var starpu_profiling_task_info::start_time
+\var struct timespec starpu_profiling_task_info::start_time
 Date of task execution beginning (relative to the initialization of StarPU).
 
-\var starpu_profiling_task_info::end_time
+\var struct timespec starpu_profiling_task_info::end_time
 Date of task execution termination (relative to the initialization of StarPU).
 
-\var starpu_profiling_task_info::release_data_start_time
+\var struct timespec starpu_profiling_task_info::release_data_start_time
 Time when the worker started releasing data.
 
-\var starpu_profiling_task_info::release_data_end_time
+\var struct timespec starpu_profiling_task_info::release_data_end_time
 Time when the worker finished releasing data.
 
-\var starpu_profiling_task_info::callback_start_time
-        Time when the worker started the application callback for the task.
+\var struct timespec starpu_profiling_task_info::callback_start_time
+Time when the worker started the application callback for the task.
 
-\var starpu_profiling_task_info::callback_end_time
-        Time when the worker finished the application callback for the task.
+\var struct timespec starpu_profiling_task_info::callback_end_time
+Time when the worker finished the application callback for the task.
 
-\var starpu_profiling_task_info::workerid
-        Identifier of the worker which has executed the task.
+\var int starpu_profiling_task_info::workerid
+Identifier of the worker which has executed the task.
 
-\var starpu_profiling_task_info::used_cycles
-        Number of cycles used by the task, only available in the MoviSim
+\var uint64_t starpu_profiling_task_info::used_cycles
+Number of cycles used by the task, only available in the MoviSim
 
-\var starpu_profiling_task_info::stall_cycles
-        Number of cycles stalled within the task, only available in the MoviSim
+\var uint64_t starpu_profiling_task_info::stall_cycles
+Number of cycles stalled within the task, only available in the MoviSim
 
-\var starpu_profiling_task_info::power_consumed
-        Power consumed by the task, only available in the MoviSim
+\var double starpu_profiling_task_info::power_consumed
+Power consumed by the task, only available in the MoviSim
 
 \struct starpu_profiling_worker_info
 This structure contains the profiling information associated to
 a worker. The timing is provided since the previous call to
 starpu_profiling_worker_get_info()
 \ingroup API_Profiling
-\var starpu_profiling_worker_info::start_time
+\var struct timespec starpu_profiling_worker_info::start_time
         Starting date for the reported profiling measurements.
-\var starpu_profiling_worker_info::total_time
+\var struct timespec starpu_profiling_worker_info::total_time
         Duration of the profiling measurement interval.
-\var starpu_profiling_worker_info::executing_time
+\var struct timespec starpu_profiling_worker_info::executing_time
         Time spent by the worker to execute tasks during the profiling measurement interval.
-\var starpu_profiling_worker_info::sleeping_time
+\var struct timespec starpu_profiling_worker_info::sleeping_time
         Time spent idling by the worker during the profiling measurement interval.
-\var starpu_profiling_worker_info::executed_tasks
+\var int starpu_profiling_worker_info::executed_tasks
         Number of tasks executed by the worker during the profiling measurement interval.
-\var starpu_profiling_worker_info::used_cycles
+\var uint64_t starpu_profiling_worker_info::used_cycles
         Number of cycles used by the worker, only available in the MoviSim
-\var starpu_profiling_worker_info::stall_cycles
+\var uint64_t starpu_profiling_worker_info::stall_cycles
         Number of cycles stalled within the worker, only available in the MoviSim
-\var starpu_profiling_worker_info::power_consumed
+\var double starpu_profiling_worker_info::power_consumed
         Power consumed by the worker, only available in the MoviSim
 
 \struct starpu_profiling_bus_info
 todo
 \ingroup API_Profiling
-\var starpu_profiling_bus_info::start_time
+\var struct timespec starpu_profiling_bus_info::start_time
         Time of bus profiling startup.
-\var starpu_profiling_bus_info::total_time
+\var struct timespec starpu_profiling_bus_info::total_time
         Total time of bus profiling.
-\var starpu_profiling_bus_info::transferred_bytes
+\var int long long starpu_profiling_bus_info::transferred_bytes
         Number of bytes transferred during profiling.
-\var starpu_profiling_bus_info::transfer_count
+\var int starpu_profiling_bus_info::transfer_count
         Number of transfers during profiling.
 
 \typedef STARPU_PROFILING_DISABLE

doc/doxygen/chapters/api/scheduling_contexts.doxy

@@ -20,19 +20,17 @@ dynamically.
 Performance counters used by the starpu to indicate the
 hypervisor how the application and the resources are executing.
 \ingroup API_Scheduling_Contexts
-\var starpu_sched_ctx_performance_counters::notify_idle_cycle
+\var void (*starpu_sched_ctx_performance_counters::notify_idle_cycle)(unsigned sched_ctx_id, int worker, double idle_time)
         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
+\var void (*starpu_sched_ctx_performance_counters::notify_pushed_task)(unsigned sched_ctx_id, int worker)
         Notifies the hypervisor that 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
+\var void (*starpu_sched_ctx_performance_counters::notify_poped_task)(unsigned sched_ctx_id, int worker)
         Informs the hypervisor that a task executing a specified number of instructions has been poped from the worker
-\var starpu_sched_ctx_performance_counters::notify_post_exec_hook
+\var void (*starpu_sched_ctx_performance_counters::notify_post_exec_task)(struct starpu_task *task, size_t data_size, uint32_t footprint, int hypervisor_tag, double flops)
         Notifies the hypervisor that a task has just been executed
-\var starpu_sched_ctx_performance_counters::notify_submitted_job
+\var void (*starpu_sched_ctx_performance_counters::notify_submitted_job)(struct starpu_task *task, uint32_t footprint, size_t data_size)
         Notifies the hypervisor that a task has just been submitted
-\var starpu_sched_ctx_performance_counters::notify_delete_context
+\var void (*starpu_sched_ctx_performance_counters::notify_delete_context)(unsigned sched_ctx)
         Notifies the hypervisor that the context was deleted
 
 

doc/doxygen/chapters/api/scheduling_policy.doxy

@@ -19,43 +19,43 @@ This structure contains all the methods that implement a
 scheduling policy. An application may specify which scheduling
 strategy in the field starpu_conf::sched_policy passed to the function
 starpu_init().
-\var starpu_sched_policy::init_sched
+\var void (*starpu_sched_policy::init_sched)(unsigned sched_ctx_id)
         Initialize the scheduling policy.
-\var starpu_sched_policy::deinit_sched
+\var void (*starpu_sched_policy::deinit_sched)(unsigned sched_ctx_id)
         Cleanup the scheduling policy.
-\var starpu_sched_policy::push_task
+\var int (*starpu_sched_policy::push_task)(struct starpu_task *)
         Insert a task into the scheduler.
-\var starpu_sched_policy::push_task_notify
+\var void (*starpu_sched_policy::push_task_notify)(struct starpu_task *, int workerid, int perf_workerid, unsigned sched_ctx_id)
         Notify the scheduler that a task was pushed on a given worker.
 	This method is called when a task that was explicitly
 	assigned to a worker becomes ready and is about to be executed
 	by the worker. This method therefore permits to keep the state
 	of the scheduler coherent even when StarPU bypasses the
 	scheduling strategy.
-\var starpu_sched_policy::pop_task
+\var struct starpu_task *(*starpu_sched_policy::pop_task)(unsigned sched_ctx_id)
         Get a task from the scheduler. The mutex associated to the
 	worker is already taken when this method is called. If this
 	method is defined as NULL, the worker will only execute tasks
 	from its local queue. In this case, the push_task method
 	should use the starpu_push_local_task method to assign tasks
 	to the different workers.
-\var starpu_sched_policy::pop_every_task
+\var struct starpu_task *(*starpu_sched_policy::pop_every_task)(unsigned sched_ctx_id)
         Remove all available tasks from the scheduler (tasks are
 	chained by the means of the field starpu_task::prev and
 	starpu_task::next). The mutex associated to the worker is
 	already taken when this method is called. This is currently
 	not used.
-\var starpu_sched_policy::pre_exec_hook
+\var void (*starpu_sched_policy::pre_exec_hook)(struct starpu_task *)
         Optional field. This method is called every time a task is starting.
-\var starpu_sched_policy::post_exec_hook
+\var void (*starpu_sched_policy::post_exec_hook)(struct starpu_task *)
         Optional field. This method is called every time a task has been executed.
-\var starpu_sched_policy::add_workers
+\var void (*starpu_sched_policy::add_workers)(unsigned sched_ctx_id, int *workerids, unsigned nworkers)
         Initialize scheduling structures corresponding to each worker used by the policy.
-\var starpu_sched_policy::remove_workers
+\var void (*starpu_sched_policy::remove_workers)(unsigned sched_ctx_id, int *workerids, unsigned nworkers)
         Deinitialize scheduling structures corresponding to each worker used by the policy.
-\var starpu_sched_policy::policy_name
+\var const char *starpu_sched_policy::policy_name
         Optional field. Name of the policy.
-\var starpu_sched_policy::policy_description
+\var const char *starpu_sched_policy::policy_description
         Optional field. Human readable description of the policy.
 
 \fn struct starpu_sched_policy **starpu_sched_get_predefined_policies()

doc/doxygen/chapters/api/task_lists.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -11,9 +11,9 @@
 \struct starpu_task_list
 Stores a double-chained list of tasks
 \ingroup API_Task_Lists
-\var starpu_task_list::head
+\var struct starpu_task *starpu_task_list::head
 head of the list
-\var starpu_task_list::tail
+\var struct starpu_task *starpu_task_list::tail
 tail of the list
 
 \fn void starpu_task_list_init(struct starpu_task_list *list)

doc/doxygen/chapters/api/top.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -65,51 +65,51 @@ todo
 \struct starpu_top_data
 todo
 \ingroup API_StarPUTop_Interface
-\var starpu_top_data::id
+\var unsigned int starpu_top_data::id
 todo
-\var starpu_top_data::name
+\var const char *starpu_top_data::name
 todo
-\var starpu_top_data::int_min_value
+\var int starpu_top_data::int_min_value
 todo
-\var starpu_top_data::int_max_value
+\var int starpu_top_data::int_max_value
 todo
-\var starpu_top_data::double_min_value
+\var double starpu_top_data::double_min_value
 todo
-\var starpu_top_data::double_max_value
+\var double starpu_top_data::double_max_value
 todo
-\var starpu_top_data::active
+\var int starpu_top_data::active
 todo
-\var starpu_top_data::type
+\var enum starpu_top_data_type starpu_top_data::type
 todo
-\var starpu_top_data::next
+\var struct starpu_top_data *starpu_top_data::next
 todo
 
 \struct starpu_top_param
 todo
 \ingroup API_StarPUTop_Interface
-\var starpu_top_param::id
+\var unsigned int starpu_top_param::id
 todo
-\var starpu_top_param::name
+\var const char *starpu_top_param::name
 todo
-\var starpu_top_param::type
+\var enum starpu_top_param_type starpu_top_param::type
 todo
-\var starpu_top_param::value
+\var void *starpu_top_param::value
 todo
-\var starpu_top_param::enum_values
+\var char **starpu_top_param::enum_values
 only for enum type can be NULL
-\var starpu_top_param::nb_values
+\var int starpu_top_param::nb_values
 todo
-\var starpu_top_param::callback
+\var void (*starpu_top_param::callback)(struct starpu_top_param*)
 todo
-\var starpu_top_param::int_min_value
+\var int starpu_top_param::int_min_value
 only for integer type
-\var starpu_top_param::int_max_value
+\var int starpu_top_param::int_max_value
 todo
-\var starpu_top_param::double_min_value
+\var double starpu_top_param::double_min_value
 only for double type
-\var starpu_top_param::double_max_value
+\var double starpu_top_param::double_max_value
 todo
-\var starpu_top_param::next
+\var struct starpu_top_param *starpu_top_param::next
 todo
 
 @name Functions to call before the initialisation

doc/doxygen/chapters/api/tree.doxy

@@ -10,17 +10,17 @@
 
 \struct starpu_tree
 \ingroup API_Tree
-\var starpu_tree::nodes
+\var struct starpu_tree **starpu_tree::nodes
 todo
-\var starpu_tree::father
+\var struct starpu_tree *starpu_tree::father
 todo
-\var starpu_tree::arity
+\var int starpu_tree::arity
 todo
-\var starpu_tree::id
+\var int starpu_tree::id
 todo
-\var starpu_tree::level
+\var int starpu_tree::level
 todo
-\var starpu_tree::is_pu
+\var int starpu_tree::is_pu
 todo
 
 \fn void starpu_tree_reset_visited(struct starpu_tree *tree, int *visited)

doc/doxygen/chapters/api/workers.doxy

@@ -69,25 +69,25 @@ be memorized using different data structures. Thus, a generic
 structure is available in order to simplify the choice of its type.
 Only the list data structure is available but further data
 structures(like tree) implementations are foreseen.
-\var starpu_worker_collection::workerids
+\var void *starpu_worker_collection::workerids
         The workerids managed by the collection
-\var starpu_worker_collection::nworkers
+\var unsigned starpu_worker_collection::nworkers
         The number of workers in the collection
-\var starpu_worker_collection::type
+\var enum starpu_worker_collection_type starpu_worker_collection::type
         The type of structure (currently ::STARPU_WORKER_LIST is the only one available)
-\var starpu_worker_collection::has_next
+\var unsigned (*starpu_worker_collection::has_next)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
         Checks if there is another element in collection
-\var starpu_worker_collection::get_next
+\var int (*starpu_worker_collection::get_next)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
         return the next element in the collection
-\var starpu_worker_collection::add
+\var int (*starpu_worker_collection::add)(struct starpu_worker_collection *workers, int worker)
         add a new element in the collection
-\var starpu_worker_collection::remove
+\var int (*starpu_worker_collection::remove)(struct starpu_worker_collection *workers, int worker)
         remove an element from the collection
-\var starpu_worker_collection::init
+\var void (*starpu_worker_collection::init)(struct starpu_worker_collection *workers)
         Initialize the collection
-\var starpu_worker_collection::deinit
+\var void (*starpu_worker_collection::deinit)(struct starpu_worker_collection *workers)
         Deinitialize the colection
-\var starpu_worker_collection::init_iterator
+\var void (*starpu_worker_collection::init_iterator)(struct starpu_worker_collection *workers, struct starpu_sched_ctx_iterator *it)
         Initialize the cursor if there is one
 
 \enum starpu_worker_collection_type
@@ -100,7 +100,7 @@ The collection is an array
 \struct starpu_sched_ctx_iterator
 \ingroup API_Workers_Properties
 Structure needed to iterate on the collection
-\var starpu_sched_ctx_iterator::cursor
+\var int starpu_sched_ctx_iterator::cursor
 The index of the current worker in the collection, needed when iterating on
 the collection.