Loading...
Searching...
No Matches
Data Partition

## Data Structures

struct | starpu_data_filter

## Basic API

void | starpu_data_partition (starpu_data_handle_t initial_handle, struct starpu_data_filter *f)
void | starpu_data_unpartition (starpu_data_handle_t root_data, unsigned gathering_node)
starpu_data_handle_t | starpu_data_get_child (starpu_data_handle_t handle, unsigned i)
int | starpu_data_get_nb_children (starpu_data_handle_t handle)
starpu_data_handle_t | starpu_data_get_sub_data (starpu_data_handle_t root_data, unsigned depth,...)
starpu_data_handle_t | starpu_data_vget_sub_data (starpu_data_handle_t root_data, unsigned depth, va_list pa)
void | starpu_data_map_filters (starpu_data_handle_t root_data, unsigned nfilters,...)
void | starpu_data_vmap_filters (starpu_data_handle_t root_data, unsigned nfilters, va_list pa)
void | starpu_data_map_filters_parray (starpu_data_handle_t root_handle, int nfilters, struct starpu_data_filter **filters)
void | starpu_data_map_filters_array (starpu_data_handle_t root_handle, int nfilters, struct starpu_data_filter *filters)

## Asynchronous API

void | starpu_data_partition_plan (starpu_data_handle_t initial_handle, struct starpu_data_filter *f, starpu_data_handle_t *children)
void | starpu_data_partition_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
void | starpu_data_partition_readonly_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
void | starpu_data_partition_readonly_submit_sequential_consistency (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int sequential_consistency)
void | starpu_data_partition_readwrite_upgrade_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
void | starpu_data_partition_readonly_downgrade_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
void | starpu_data_unpartition_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int gathering_node)
void | starpu_data_unpartition_readonly_submit (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int gathering_node)
void | starpu_data_partition_clean (starpu_data_handle_t root_data, unsigned nparts, starpu_data_handle_t *children)
void | starpu_data_partition_clean_node (starpu_data_handle_t root_data, unsigned nparts, starpu_data_handle_t *children, int gather_node)
void | starpu_data_unpartition_submit_sequential_consistency_cb (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int gather_node, int sequential_consistency, void(*callback_func)(void *), void *callback_arg)
void | starpu_data_partition_submit_sequential_consistency (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int sequential_consistency)
void | starpu_data_unpartition_submit_sequential_consistency (starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int gathering_node, int sequential_consistency)

## Predefined BCSR Filter Functions

Predefined partitioning functions for BCSR data. Examples on how to use them are shown in PartitioningData.
void | starpu_bcsr_filter_canonical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
unsigned | starpu_bcsr_filter_canonical_block_get_nchildren (struct starpu_data_filter *f, starpu_data_handle_t handle)
struct starpu_data_interface_ops * | starpu_bcsr_filter_canonical_block_child_ops (struct starpu_data_filter *f, unsigned child)
void | starpu_bcsr_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)

## Predefined CSR Filter Functions

Predefined partitioning functions for CSR data. Examples on how to use them are shown in PartitioningData.
void | starpu_csr_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)

## Predefined Matrix Filter Functions

Predefined partitioning functions for matrix data. Examples on how to use them are shown in PartitioningData. Note: this is using the C element order which is row-major, i.e. elements with consecutive x coordinates are consecutive in memory.
void | starpu_matrix_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_matrix_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_matrix_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_matrix_filter_vertical_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_matrix_filter_pick_vector_y (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_matrix_filter_pick_vector_child_ops (struct starpu_data_filter *f, unsigned child)
void | starpu_matrix_filter_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_matrix_filter_pick_variable_child_ops (struct starpu_data_filter *f, unsigned child)

## Predefined Vector Filter Functions

Predefined partitioning functions for vector data. Examples on how to use them are shown in PartitioningData.
void | starpu_vector_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_vector_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_vector_filter_list_long (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_vector_filter_list (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_vector_filter_divide_in_2 (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_vector_filter_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_vector_filter_pick_variable_child_ops (struct starpu_data_filter *f, unsigned child)

## Predefined Block Filter Functions

Predefined partitioning functions for block data. Examples on how to use them are shown in PartitioningData. An example is available in `examples/filters/shadow3d.c` Note: this is using the C element order which is row-major, i.e. elements with consecutive x coordinates are consecutive in memory.
void | starpu_block_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_vertical_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_depth_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_depth_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_pick_matrix_z (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_block_filter_pick_matrix_y (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_block_filter_pick_matrix_child_ops (struct starpu_data_filter *f, unsigned child)
void | starpu_block_filter_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_block_filter_pick_variable_child_ops (struct starpu_data_filter *f, unsigned child)

## Predefined Tensor Filter Functions

Predefined partitioning functions for tensor data.
void | starpu_tensor_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_vertical_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_vertical_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_depth_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_depth_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_time_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_time_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_pick_block_t (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_pick_block_z (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_tensor_filter_pick_block_y (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_tensor_filter_pick_block_child_ops (struct starpu_data_filter *f, unsigned child)
void | starpu_tensor_filter_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_tensor_filter_pick_variable_child_ops (struct starpu_data_filter *f, unsigned child)

## Predefined Ndim Filter Functions

Predefined partitioning functions for ndim array data.
void | starpu_ndim_filter_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_block_shadow (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_to_tensor (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_to_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_to_matrix (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_to_vector (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_to_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_pick_ndim (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_5d_pick_tensor (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_4d_pick_block (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_3d_pick_matrix (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_2d_pick_vector (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_1d_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
void | starpu_ndim_filter_pick_variable (void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
struct starpu_data_interface_ops * | starpu_ndim_filter_pick_tensor_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_pick_block_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_pick_matrix_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_pick_vector_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_pick_variable_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_to_tensor_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_to_block_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_to_matrix_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_to_vector_child_ops (struct starpu_data_filter *f, unsigned child)
struct starpu_data_interface_ops * | starpu_ndim_filter_to_variable_child_ops (struct starpu_data_filter *f, unsigned child)
void | starpu_filter_nparts_compute_chunk_size_and_offset (unsigned n, unsigned nparts, size_t elemsize, unsigned id, unsigned blocksize, unsigned *chunk_size, size_t *offset)

## Detailed Description

## Data Structure Documentation

## starpu_data_filter

struct starpu_data_filter

Describe a data partitioning operation, to be given to starpu_data_partition(). See DefiningANewDataFilter for more details.

### Data Fields

void(* | filter_func )(void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts)
unsigned | nchildren
unsigned(* | get_nchildren )(struct starpu_data_filter *, starpu_data_handle_t initial_handle)
struct starpu_data_interface_ops *(* | get_child_ops )(struct starpu_data_filter *, unsigned id)
unsigned | filter_arg
void * | filter_arg_ptr

#### Field Documentation

## filter_func

void(* starpu_data_filter::filter_func) (void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts)

Fill the `child_interface` structure with interface information for the `i` -th child of the parent `father_interface` (among `nparts`). The `filter` structure is provided, allowing to inspect the starpu_data_filter::filter_arg and starpu_data_filter::filter_arg_ptr parameters. The details of what needs to be filled in `child_interface` vary according to the data interface, but generally speaking:

- `id` is usually just copied over from the father, when the sub data has the same structure as the father, e.g. a subvector is a vector, a submatrix is a matrix, etc. This is however not the case for instance when dividing a BCSR matrix into its dense blocks, which then are matrices.
- `nx`, `ny` and alike are usually divided by the number of subdata, depending how the subdivision is done (e.g. nx division vs ny division for vertical matrix division vs horizontal matrix division).
- `ld` for matrix interfaces are usually just copied over: the leading dimension (ld) usually does not change.
- `elemsize` is usually just copied over.
- `ptr`, the pointer to the data, has to be computed according to `i` and the father's `ptr`, so as to point to the start of the sub data. This should however be done only if the father has `ptr` different from NULL: in the OpenCL case notably, the `dev_handle` and `offset` fields are used instead.
- `dev_handle` should be just copied over from the parent.
- `offset` has to be computed according to `i` and the father's `offset`, so as to provide the offset of the start of the sub data. This is notably used for the OpenCL case.

## nchildren

unsigned starpu_data_filter::nchildren

Number of parts to partition the data into.

## get_nchildren

unsigned(* starpu_data_filter::get_nchildren) (struct starpu_data_filter *, starpu_data_handle_t initial_handle)

Return the number of children. This can be used instead of starpu_data_filter::nchildren when the number of children depends on the actual data (e.g. the number of blocks in a sparse matrix).

## get_child_ops

struct starpu_data_interface_ops *(* starpu_data_filter::get_child_ops) (struct starpu_data_filter *, unsigned id)

When children use different data interface, return which interface is used by child number `id`.

## filter_arg

unsigned starpu_data_filter::filter_arg

Additional parameter for the filter function

## filter_arg_ptr

void* starpu_data_filter::filter_arg_ptr

Additional pointer parameter for the filter function, such as the sizes of the different parts.

## Function Documentation

## starpu_data_partition()

void starpu_data_partition | ( | starpu_data_handle_t | initial_handle,
|  | struct starpu_data_filter * | f
| ) |  |

Request the partitioning of `initial_handle` into several subdata according to the filter `f`.

Here an example of how to use the function.

struct starpu_data_filter f =
{
.filter_func = starpu_matrix_filter_block,
.nchildren = nslicesx
};
starpu_data_partition(A_handle, &f);
starpu_data_filter::filter_func
void(* filter_func)(void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts)
Definition starpu_data_filters.h:79
starpu_data_partition
void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_data_filter *f)
starpu_matrix_filter_block
void starpu_matrix_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
starpu_data_filter
Definition starpu_data_filters.h:40

See PartitioningData for more details.

## starpu_data_unpartition()

void starpu_data_unpartition | ( | starpu_data_handle_t | root_data,
|  | unsigned | gathering_node
| ) |  |

Unapply the filter which has been applied to `root_data`, thus unpartitioning the data. The pieces of data are collected back into one big piece in the `gathering_node` (usually STARPU_MAIN_RAM). Tasks working on the partitioned data will be waited for by starpu_data_unpartition().

Here an example of how to use the function.

starpu_data_unpartition(A_handle, STARPU_MAIN_RAM);
STARPU_MAIN_RAM
#define STARPU_MAIN_RAM
Definition starpu_task.h:144
starpu_data_unpartition
void starpu_data_unpartition(starpu_data_handle_t root_data, unsigned gathering_node)

See PartitioningData for more details.

## starpu_data_get_child()

starpu_data_handle_t starpu_data_get_child | ( | starpu_data_handle_t | handle,
|  | unsigned | i
| ) |  |

Return the `i` -th child of the given `handle`, which must have been partitioned beforehand. See PartitioningData for more details.

## starpu_data_get_nb_children()

int starpu_data_get_nb_children | ( | starpu_data_handle_t | handle | ) |

Return the number of children `handle` has been partitioned into. See PartitioningData for more details.

## starpu_data_get_sub_data()

starpu_data_handle_t starpu_data_get_sub_data | ( | starpu_data_handle_t | root_data,
|  | unsigned | depth,
|  |  | ...
| ) |  |

After partitioning a StarPU data by applying a filter, starpu_data_get_sub_data() can be used to get handles for each of the data portions. `root_data` is the parent data that was partitioned. `depth` is the number of filters to traverse (in case several filters have been applied, to e.g. partition in row blocks, and then in column blocks), and the subsequent parameters are the indexes. The function returns a handle to the subdata.

Here an example of how to use the function.

h = starpu_data_get_sub_data(A_handle, 1, taskx);
starpu_data_get_sub_data
starpu_data_handle_t starpu_data_get_sub_data(starpu_data_handle_t root_data, unsigned depth,...)

See PartitioningData for more details.

## starpu_data_vget_sub_data()

starpu_data_handle_t starpu_data_vget_sub_data | ( | starpu_data_handle_t | root_data,
|  | unsigned | depth,
|  | va_list | pa
| ) |  |

Similar to starpu_data_get_sub_data() but use a `va_list` for the parameter list. See PartitioningData for more details.

## starpu_data_map_filters()

void starpu_data_map_filters | ( | starpu_data_handle_t | root_data,
|  | unsigned | nfilters,
|  |  | ...
| ) |  |

Apply `nfilters` filters to the handle designated by `root_handle` recursively. `nfilters` pointers to variables of the type starpu_data_filter should be given. See PartitioningData for more details.

## starpu_data_vmap_filters()

void starpu_data_vmap_filters | ( | starpu_data_handle_t | root_data,
|  | unsigned | nfilters,
|  | va_list | pa
| ) |  |

Apply `nfilters` filters to the handle designated by `root_handle` recursively. Use a `va_list` of pointers to variables of the type starpu_data_filter. See PartitioningData for more details.

## starpu_data_map_filters_parray()

void starpu_data_map_filters_parray | ( | starpu_data_handle_t | root_handle,
|  | int | nfilters,
|  | struct starpu_data_filter ** | filters
| ) |  |

Apply `nfilters` filters to the handle designated by `root_handle` recursively. The pointer of the filter list `filters` of the type starpu_data_filter should be given. See PartitioningData for more details.

## starpu_data_map_filters_array()

void starpu_data_map_filters_array | ( | starpu_data_handle_t | root_handle,
|  | int | nfilters,
|  | struct starpu_data_filter * | filters
| ) |  |

Apply `nfilters` filters to the handle designated by `root_handle` recursively. The list of filter `filters` of the type starpu_data_filter should be given. See PartitioningData for more details.

## starpu_data_partition_plan()

void starpu_data_partition_plan | ( | starpu_data_handle_t | initial_handle,
|  | struct starpu_data_filter * | f,
|  | starpu_data_handle_t * | children
| ) |  |

Plan to partition `initial_handle` into several subdata according to the filter `f`. The handles are returned into the `children` array, which has to be the same size as the number of parts described in `f`. These handles are not immediately usable, starpu_data_partition_submit() has to be called to submit the actual partitioning.

Here is an example of how to use the function:

starpu_data_handle_t children[nslicesx];
struct starpu_data_filter f =
{
.filter_func = starpu_matrix_filter_block,
.nchildren = nslicesx
};
starpu_data_partition_plan(A_handle, &f, children);
starpu_data_handle_t
struct _starpu_data_state * starpu_data_handle_t
Definition starpu_data.h:45
starpu_data_partition_plan
void starpu_data_partition_plan(starpu_data_handle_t initial_handle, struct starpu_data_filter *f, starpu_data_handle_t *children)

See AsynchronousPartitioning for more details.

## starpu_data_partition_submit()

void starpu_data_partition_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children
| ) |  |

Submit the actual partitioning of `initial_handle` into the `nparts` `children` handles. This call is asynchronous, it only submits that the partitioning should be done, so that the `children` handles can now be used to submit tasks, and `initial_handle` can not be used to submit tasks any more (to guarantee coherency). For instance,

starpu_data_partition_submit(A_handle, nslicesx, children);
starpu_data_partition_submit
void starpu_data_partition_submit(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)

See AsynchronousPartitioning for more details.

## starpu_data_partition_readonly_submit()

void starpu_data_partition_readonly_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children
| ) |  |

Similar to starpu_data_partition_submit(), but do not invalidate `initial_handle`. This allows to continue using it, but the application has to be careful not to write to `initial_handle` or `children` handles, only read from them, since the coherency is otherwise not guaranteed. This thus allows to submit various tasks which concurrently read from various partitions of the data.

When the application wants to write to `initial_handle` again, it should call starpu_data_unpartition_submit(), which will properly add dependencies between the reads on the `children` and the writes to be submitted.

If instead the application wants to write to `children` handles, it should call starpu_data_partition_readwrite_upgrade_submit(), which will correctly add dependencies between the reads on the `initial_handle` and the writes to be submitted. See AsynchronousPartitioning for more details.

## starpu_data_partition_readonly_submit_sequential_consistency()

void starpu_data_partition_readonly_submit_sequential_consistency | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | sequential_consistency
| ) |  |

Similar to starpu_data_partition_readonly_submit(), but allow to specify the coherency to be used for the main data `initial_handle`. See AsynchronousPartitioning for more details.

## starpu_data_partition_readwrite_upgrade_submit()

void starpu_data_partition_readwrite_upgrade_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children
| ) |  |

Assume that a partitioning of `initial_handle` has already been submitted in readonly mode through starpu_data_partition_readonly_submit(), and will upgrade that partitioning into read-write mode for the `children`, by invalidating `initial_handle`, and adding the necessary dependencies. See AsynchronousPartitioning for more details.

## starpu_data_partition_readonly_downgrade_submit()

void starpu_data_partition_readonly_downgrade_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children
| ) |  |

Assume that a partitioning of `initial_handle` has already been submitted in read-write mode through starpu_data_partition_submit(), and will downgrade that partitioning into read-only mode for the `children`, fetching data back to the `initial_handle`, and adding the necessary dependencies. See AsynchronousPartitioning for more details.

## starpu_data_unpartition_submit()

void starpu_data_unpartition_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | gathering_node
| ) |  |

Assuming that `initial_handle` is partitioned into `children`, submit an unpartitionning of `initial_handle`, i.e. submit a gathering of the pieces on the requested `gathering_node` memory node, and submit an invalidation of the children. See AsynchronousPartitioning for more details.

## starpu_data_unpartition_readonly_submit()

void starpu_data_unpartition_readonly_submit | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | gathering_node
| ) |  |

Similar to starpu_data_partition_submit(), but do not invalidate `initial_handle`. This allows to continue using it, but the application has to be careful not to write to `initial_handle` or `children` handles, only read from them, since the coherency is otherwise not guaranteed. This thus allows to submit various tasks which concurrently read from various partitions of the data. See AsynchronousPartitioning for more details.

## starpu_data_partition_clean()

void starpu_data_partition_clean | ( | starpu_data_handle_t | root_data,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children
| ) |  |

Clear the partition planning established between `root_data` and `children` with starpu_data_partition_plan(). This will notably submit an unregister all the `children`, which can thus not be used any more afterwards. See AsynchronousPartitioning for more details.

## starpu_data_partition_clean_node()

void starpu_data_partition_clean_node | ( | starpu_data_handle_t | root_data,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | gather_node
| ) |  |

Similar to starpu_data_partition_clean() but the root data will be gathered on the given node. See AsynchronousPartitioning for more details.

## starpu_data_unpartition_submit_sequential_consistency_cb()

void starpu_data_unpartition_submit_sequential_consistency_cb | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | gather_node,
|  | int | sequential_consistency,
|  | void(*)(void *) | callback_func,
|  | void * | callback_arg
| ) |  |

Similar to starpu_data_unpartition_submit_sequential_consistency() but allow to specify a callback function for the unpartitiong task. See AsynchronousPartitioning for more details.

## starpu_data_partition_submit_sequential_consistency()

void starpu_data_partition_submit_sequential_consistency | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | sequential_consistency
| ) |  |

Similar to starpu_data_partition_submit() but also allow to specify the coherency to be used for the main data `initial_handle` through the parameter `sequential_consistency`. See AsynchronousPartitioning for more details.

## starpu_data_unpartition_submit_sequential_consistency()

void starpu_data_unpartition_submit_sequential_consistency | ( | starpu_data_handle_t | initial_handle,
|  | unsigned | nparts,
|  | starpu_data_handle_t * | children,
|  | int | gathering_node,
|  | int | sequential_consistency
| ) |  |

Similar to starpu_data_unpartition_submit() but also allow to specify the coherency to be used for the main data `initial_handle` through the parameter `sequential_consistency`. See AsynchronousPartitioning for more details.

## starpu_bcsr_filter_canonical_block()

void starpu_bcsr_filter_canonical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block-sparse matrix into dense matrices. starpu_data_filter::get_child_ops needs to be set to starpu_bcsr_filter_canonical_block_child_ops() and starpu_data_filter::get_nchildren set to starpu_bcsr_filter_canonical_block_get_nchildren().

See BCSRDataInterface for more details.

## starpu_bcsr_filter_canonical_block_get_nchildren()

unsigned starpu_bcsr_filter_canonical_block_get_nchildren | ( | struct starpu_data_filter * | f,
|  | starpu_data_handle_t | handle
| ) |  |

Return the number of children obtained with starpu_bcsr_filter_canonical_block(). See BCSRDataInterface for more details.

## starpu_bcsr_filter_canonical_block_child_ops()

struct starpu_data_interface_ops * starpu_bcsr_filter_canonical_block_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_bcsr_filter_canonical_block(). See BCSRDataInterface for more details.

## starpu_bcsr_filter_vertical_block()

void starpu_bcsr_filter_vertical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block-sparse matrix into block-sparse matrices.

The split is done along the leading dimension, i.e. along adjacent nnz blocks.

See BCSRDataInterface for more details.

## starpu_csr_filter_vertical_block()

void starpu_csr_filter_vertical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block-sparse matrix into vertical block-sparse matrices.

See CSRDataInterface for more details.

## starpu_matrix_filter_block()

void starpu_matrix_filter_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a dense Matrix along the x dimension, thus getting (x/`nparts` ,y) matrices. If `nparts` does not divide x, the last submatrix contains the remainder.

See MatrixDataInterface for more details.

## starpu_matrix_filter_block_shadow()

void starpu_matrix_filter_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a dense Matrix along the x dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting ((x-2*shadow)/`nparts` +2*shadow,y) matrices. If `nparts` does not divide x-2*shadow, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts. A usage example is available in examples/filters/shadow2d.c

See MatrixDataInterface for more details.

## starpu_matrix_filter_vertical_block()

void starpu_matrix_filter_vertical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a dense Matrix along the y dimension, thus getting (x,y/`nparts`) matrices. If `nparts` does not divide y, the last submatrix contains the remainder.

See MatrixDataInterface for more details.

## starpu_matrix_filter_vertical_block_shadow()

void starpu_matrix_filter_vertical_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a dense Matrix along the y dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,(y-2*shadow)/`nparts` +2*shadow) matrices. If `nparts` does not divide y-2*shadow, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts. A usage example is available in examples/filters/shadow2d.c

See MatrixDataInterface for more details.

## starpu_matrix_filter_pick_vector_y()

void starpu_matrix_filter_pick_vector_y | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous vectors from a matrix along the Y dimension. The starting position on Y-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_matrix_filter_pick_vector_child_ops(). A usage example is available in examples/filters/fmatrix_pick_vector.c

See MatrixDataInterface for more details.

## starpu_matrix_filter_pick_vector_child_ops()

struct starpu_data_interface_ops * starpu_matrix_filter_pick_vector_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_matrix_filter_pick_vector_y(). See MatrixDataInterface for more details.

## starpu_matrix_filter_pick_variable()

void starpu_matrix_filter_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a matrix. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_matrix_filter_pick_variable_child_ops(). A usage example is available in examples/filters/fmatrix_pick_variable.c

See MatrixDataInterface for more details.

## starpu_matrix_filter_pick_variable_child_ops()

struct starpu_data_interface_ops * starpu_matrix_filter_pick_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_matrix_filter_pick_variable(). See MatrixDataInterface for more details.

## starpu_vector_filter_block()

void starpu_vector_filter_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Return in `child_interface` the `id` th element of the vector represented by `father_interface` once partitioned in `nparts` chunks of equal size.

See VectorDataInterface for more details.

## starpu_vector_filter_block_shadow()

void starpu_vector_filter_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Return in `child_interface` the `id` th element of the vector represented by `father_interface` once partitioned in `nparts` chunks of equal size with a shadow border starpu_data_filter::filter_arg_ptr, thus getting a vector of size `(n-2*shadow)/nparts+2*shadow`. The starpu_data_filter::filter_arg_ptr field of `f` must be the shadow size casted into `void*`.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts. An usage example is available in examples/filters/shadow.c

See VectorDataInterface for more details.

## starpu_vector_filter_list_long()

void starpu_vector_filter_list_long | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Return in `child_interface` the `id` th element of the vector represented by `father_interface` once partitioned into `nparts` chunks according to the starpu_data_filter::filter_arg_ptr field of `f`. The starpu_data_filter::filter_arg_ptr field must point to an array of `nparts` long elements, each of which specifies the number of elements in each chunk of the partition.

See VectorDataInterface for more details.

## starpu_vector_filter_list()

void starpu_vector_filter_list | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Return in `child_interface` the `id` th element of the vector represented by `father_interface` once partitioned into `nparts` chunks according to the starpu_data_filter::filter_arg_ptr field of `f`. The starpu_data_filter::filter_arg_ptr field must point to an array of `nparts` uint32_t elements, each of which specifies the number of elements in each chunk of the partition.

See VectorDataInterface for more details.

## starpu_vector_filter_divide_in_2()

void starpu_vector_filter_divide_in_2 | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Return in `child_interface` the `id` th element of the vector represented by `father_interface` once partitioned in `2` chunks of equal size, ignoring nparts. Thus, `id` must be `0` or `1`.

See VectorDataInterface for more details.

## starpu_vector_filter_pick_variable()

void starpu_vector_filter_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a vector. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_vector_filter_pick_variable_child_ops(). A usage example is available in examples/filters/fvector_pick_variable.c

See VectorDataInterface for more details.

## starpu_vector_filter_pick_variable_child_ops()

struct starpu_data_interface_ops * starpu_vector_filter_pick_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_vector_filter_pick_variable(). See VectorDataInterface for more details.

## starpu_block_filter_block()

void starpu_block_filter_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the X dimension, thus getting (x/`nparts` ,y,z) 3D matrices. If `nparts` does not divide x, the last submatrix contains the remainder.

See BlockDataInterface for more details.

## starpu_block_filter_block_shadow()

void starpu_block_filter_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the X dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting ((x-2*shadow)/`nparts` +2*shadow,y,z) blocks. If `nparts` does not divide x, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See BlockDataInterface for more details.

## starpu_block_filter_vertical_block()

void starpu_block_filter_vertical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the Y dimension, thus getting (x,y/`nparts` ,z) blocks. If `nparts` does not divide y, the last submatrix contains the remainder.

See BlockDataInterface for more details.

## starpu_block_filter_vertical_block_shadow()

void starpu_block_filter_vertical_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the Y dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,(y-2*shadow)/`nparts` +2*shadow,z) 3D matrices. If `nparts` does not divide y, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See BlockDataInterface for more details.

## starpu_block_filter_depth_block()

void starpu_block_filter_depth_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the Z dimension, thus getting (x,y,z/`nparts`) blocks. If `nparts` does not divide z, the last submatrix contains the remainder.

See BlockDataInterface for more details.

## starpu_block_filter_depth_block_shadow()

void starpu_block_filter_depth_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a block along the Z dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,y,(z-2*shadow)/`nparts` +2*shadow) blocks. If `nparts` does not divide z, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See BlockDataInterface for more details.

## starpu_block_filter_pick_matrix_z()

void starpu_block_filter_pick_matrix_z | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous matrices from a block along the Z dimension. The starting position on Z-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_block_filter_pick_matrix_child_ops(). A usage example is available in examples/filters/fblock_pick_matrix.c

See BlockDataInterface for more details.

## starpu_block_filter_pick_matrix_y()

void starpu_block_filter_pick_matrix_y | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous matrices from a block along the Y dimension. The starting position on Y-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_block_filter_pick_matrix_child_ops(). A usage example is available in examples/filters/fblock_pick_matrix.c

See BlockDataInterface for more details.

## starpu_block_filter_pick_matrix_child_ops()

struct starpu_data_interface_ops * starpu_block_filter_pick_matrix_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_block_filter_pick_matrix_z() and starpu_block_filter_pick_matrix_y(). See BlockDataInterface for more details.

## starpu_block_filter_pick_variable()

void starpu_block_filter_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a block. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_block_filter_pick_variable_child_ops(). A usage example is available in examples/filters/fblock_pick_variable.c

See BlockDataInterface for more details.

## starpu_block_filter_pick_variable_child_ops()

struct starpu_data_interface_ops * starpu_block_filter_pick_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_block_filter_pick_variable(). See BlockDataInterface for more details.

## starpu_tensor_filter_block()

void starpu_tensor_filter_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the X dimension, thus getting (x/`nparts` ,y,z,t) tensors. If `nparts` does not divide x, the last submatrix contains the remainder.

See TensorDataInterface for more details.

## starpu_tensor_filter_block_shadow()

void starpu_tensor_filter_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the X dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting ((x-2*shadow)/`nparts` +2*shadow,y,z,t) tensors. If `nparts` does not divide x, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See TensorDataInterface for more details.

## starpu_tensor_filter_vertical_block()

void starpu_tensor_filter_vertical_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the Y dimension, thus getting (x,y/`nparts` ,z,t) tensors. If `nparts` does not divide y, the last submatrix contains the remainder.

See TensorDataInterface for more details.

## starpu_tensor_filter_vertical_block_shadow()

void starpu_tensor_filter_vertical_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the Y dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,(y-2*shadow)/`nparts` +2*shadow,z,t) tensors. If `nparts` does not divide y, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See TensorDataInterface for more details.

## starpu_tensor_filter_depth_block()

void starpu_tensor_filter_depth_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the Z dimension, thus getting (x,y,z/`nparts`,t) tensors. If `nparts` does not divide z, the last submatrix contains the remainder.

See TensorDataInterface for more details.

## starpu_tensor_filter_depth_block_shadow()

void starpu_tensor_filter_depth_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the Z dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,y,(z-2*shadow)/`nparts` +2*shadow,t) tensors. If `nparts` does not divide z, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See TensorDataInterface for more details.

## starpu_tensor_filter_time_block()

void starpu_tensor_filter_time_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the T dimension, thus getting (x,y,z,t/`nparts`) tensors. If `nparts` does not divide t, the last submatrix contains the remainder.

See TensorDataInterface for more details.

## starpu_tensor_filter_time_block_shadow()

void starpu_tensor_filter_time_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a tensor along the T dimension, with a shadow border starpu_data_filter::filter_arg_ptr, thus getting (x,y,z,(t-2*shadow)/`nparts` +2*shadow) tensors. If `nparts` does not divide t, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See TensorDataInterface for more details.

## starpu_tensor_filter_pick_block_t()

void starpu_tensor_filter_pick_block_t | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous blocks from a tensor along the T dimension. The starting position on T-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_tensor_filter_pick_block_child_ops(). A usage example is available in examples/filters/ftensor_pick_block.c

See TensorDataInterface for more details.

## starpu_tensor_filter_pick_block_z()

void starpu_tensor_filter_pick_block_z | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous blocks from a tensor along the Z dimension. The starting position on Z-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_tensor_filter_pick_block_child_ops(). A usage example is available in examples/filters/ftensor_pick_block.c

See TensorDataInterface for more details.

## starpu_tensor_filter_pick_block_y()

void starpu_tensor_filter_pick_block_y | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous blocks from a tensor along the Y dimension. The starting position on Y-axis is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_tensor_filter_pick_block_child_ops(). A usage example is available in examples/filters/ftensor_pick_block.c

See TensorDataInterface for more details.

## starpu_tensor_filter_pick_block_child_ops()

struct starpu_data_interface_ops * starpu_tensor_filter_pick_block_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_tensor_filter_pick_block_t(), starpu_tensor_filter_pick_block_z() and starpu_tensor_filter_pick_block_y(). See TensorDataInterface for more details.

## starpu_tensor_filter_pick_variable()

void starpu_tensor_filter_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a tensor. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_tensor_filter_pick_variable_child_ops(). A usage example is available in examples/filters/ftensor_pick_variable.c

See TensorDataInterface for more details.

## starpu_tensor_filter_pick_variable_child_ops()

struct starpu_data_interface_ops * starpu_tensor_filter_pick_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_tensor_filter_pick_variable(). See TensorDataInterface for more details.

## starpu_ndim_filter_block()

void starpu_ndim_filter_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a ndim array along the given dimension set in starpu_data_filter::filter_arg. If `nparts` does not divide the element number on dimension, the last submatrix contains the remainder.

See NdimDataInterface for more details.

## starpu_ndim_filter_block_shadow()

void starpu_ndim_filter_block_shadow | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a ndim array along the given dimension set in starpu_data_filter::filter_arg, with a shadow border starpu_data_filter::filter_arg_ptr. If `nparts` does not divide the element number on dimension, the last submatrix contains the remainder.

IMPORTANT: This can only be used for read-only access, as no coherency is enforced for the shadowed parts.

See NdimDataInterface for more details.

## starpu_ndim_filter_to_tensor()

void starpu_ndim_filter_to_tensor | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a 4-dim array into `nparts` tensors along the given dimension set in starpu_data_filter::filter_arg.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_to_tensor_child_ops(). A usage example is available in examples/filters/fndim_to_tensor.c

See NdimDataInterface for more details.

## starpu_ndim_filter_to_block()

void starpu_ndim_filter_to_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a 3-dim array into `nparts` blocks along the given dimension set in starpu_data_filter::filter_arg.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_to_block_child_ops(). A usage example is available in examples/filters/fndim_to_block.c

See NdimDataInterface for more details.

## starpu_ndim_filter_to_matrix()

void starpu_ndim_filter_to_matrix | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a 2-dim array into `nparts` matrices along the given dimension set in starpu_data_filter::filter_arg.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_to_matrix_child_ops(). A usage example is available in examples/filters/fndim_to_matrix.c

See NdimDataInterface for more details.

## starpu_ndim_filter_to_vector()

void starpu_ndim_filter_to_vector | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Partition a 1-dim array into `nparts` vectors.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_to_vector_child_ops(). A usage example is available in examples/filters/fndim_to_vector.c

See NdimDataInterface for more details.

## starpu_ndim_filter_to_variable()

void starpu_ndim_filter_to_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Transfer a 0-dim array to a variable.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_to_variable_child_ops(). A usage example is available in examples/filters/fndim_to_variable.c

See NdimDataInterface for more details.

## starpu_ndim_filter_pick_ndim()

void starpu_ndim_filter_pick_ndim | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous (n-1)dim arrays from a ndim array along the given dimension set in starpu_data_filter::filter_arg. The starting position is set in starpu_data_filter::filter_arg_ptr.

A usage example is available in examples/filters/fndim_pick_ndim.c

See NdimDataInterface for more details.

## starpu_ndim_filter_5d_pick_tensor()

void starpu_ndim_filter_5d_pick_tensor | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous tensors from a 5-dim array along the given dimension set in starpu_data_filter::filter_arg. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_tensor_child_ops(). A usage example is available in examples/filters/fndim_5d_pick_tensor.c

See NdimDataInterface for more details.

## starpu_ndim_filter_4d_pick_block()

void starpu_ndim_filter_4d_pick_block | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous blocks from a 4-dim array along the given dimension set in starpu_data_filter::filter_arg. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_block_child_ops(). A usage example is available in examples/filters/fndim_4d_pick_block.c

See NdimDataInterface for more details.

## starpu_ndim_filter_3d_pick_matrix()

void starpu_ndim_filter_3d_pick_matrix | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous matrices from a 3-dim array along the given dimension set in starpu_data_filter::filter_arg. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_matrix_child_ops(). A usage example is available in examples/filters/fndim_3d_pick_matrix.c

See NdimDataInterface for more details.

## starpu_ndim_filter_2d_pick_vector()

void starpu_ndim_filter_2d_pick_vector | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous vectors from a 2-dim array along the given dimension set in starpu_data_filter::filter_arg. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_vector_child_ops(). A usage example is available in examples/filters/fndim_2d_pick_vector.c

See NdimDataInterface for more details.

## starpu_ndim_filter_1d_pick_variable()

void starpu_ndim_filter_1d_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a 1-dim array. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_variable_child_ops(). A usage example is available in examples/filters/fndim_1d_pick_variable.c

See NdimDataInterface for more details.

## starpu_ndim_filter_pick_variable()

void starpu_ndim_filter_pick_variable | ( | void * | father_interface,
|  | void * | child_interface,
|  | struct starpu_data_filter * | f,
|  | unsigned | id,
|  | unsigned | nparts
| ) |  |

Pick `nparts` contiguous variables from a ndim array. The starting position is set in starpu_data_filter::filter_arg_ptr.

starpu_data_filter::get_child_ops needs to be set to starpu_ndim_filter_pick_variable_child_ops(). A usage example is available in examples/filters/fndim_pick_variable.c

See NdimDataInterface for more details.

## starpu_ndim_filter_pick_tensor_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_pick_tensor_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_pick_tensor(). See NdimDataInterface for more details.

## starpu_ndim_filter_pick_block_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_pick_block_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_pick_block(). See NdimDataInterface for more details.

## starpu_ndim_filter_pick_matrix_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_pick_matrix_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_pick_matrix(). See NdimDataInterface for more details.

## starpu_ndim_filter_pick_vector_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_pick_vector_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_pick_vector(). See NdimDataInterface for more details.

## starpu_ndim_filter_pick_variable_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_pick_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_pick_variable(). See NdimDataInterface for more details.

## starpu_ndim_filter_to_tensor_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_to_tensor_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_to_tensor(). See NdimDataInterface for more details.

## starpu_ndim_filter_to_block_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_to_block_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_to_block(). See NdimDataInterface for more details.

## starpu_ndim_filter_to_matrix_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_to_matrix_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_to_matrix(). See NdimDataInterface for more details.

## starpu_ndim_filter_to_vector_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_to_vector_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_to_vector(). See NdimDataInterface for more details.

## starpu_ndim_filter_to_variable_child_ops()

struct starpu_data_interface_ops * starpu_ndim_filter_to_variable_child_ops | ( | struct starpu_data_filter * | f,
|  | unsigned | child
| ) |  |

Return the child_ops of the partition obtained with starpu_ndim_filter_to_variable(). See NdimDataInterface for more details.

## starpu_filter_nparts_compute_chunk_size_and_offset()

void starpu_filter_nparts_compute_chunk_size_and_offset | ( | unsigned | n,
|  | unsigned | nparts,
|  | size_t | elemsize,
|  | unsigned | id,
|  | unsigned | blocksize,
|  | unsigned * | chunk_size,
|  | size_t * | offset
| ) |  |

Given an integer `n`, `n` the number of parts it must be divided in, `id` the part currently considered, determines the `chunk_size` and the `offset`, taking into account the size of the elements stored in the data structure `elemsize` and `blocksize`, which is most often 1. See DefiningANewDataFilter for more details.