|
std::function< int64_t(int64_t)> | slate::func::uniform_blocksize (int64_t n, int64_t nb) |
| Creates a uniform blocksize.
|
|
int64_t | slate::func::max_blocksize (int64_t nt, std::function< int64_t(int64_t)> size) |
| Computes the largest block given a blocksize function.
|
|
std::function< int(ij_tuple)> | slate::func::device_2d_grid (GridOrder order, int64_t m, int64_t n, int64_t p, int64_t q) |
| Distributes tiles to devices in a 2d block-cyclic fashion.
|
|
std::function< int(ij_tuple)> | slate::func::device_1d_grid (GridOrder order, int64_t block_size, int size) |
| Distributes tiles to devices in a 1d block-cyclic fashion.
|
|
std::function< int(ij_tuple)> | slate::func::process_2d_grid (GridOrder order, int64_t p, int64_t q) |
| Distributes tiles to processes in a 2d cyclic fashion, resulting in the elements being distributed in a 2d block-cyclic fashion.
|
|
std::function< int(ij_tuple)> | slate::func::process_1d_grid (GridOrder order, int size) |
| Distributes tiles to processes in a 1d cyclic fashion, resulting in the elements being distributed in a 1d block-cyclic fashion.
|
|
std::function< int(ij_tuple)> | slate::func::transpose_grid (std::function< int(ij_tuple)> old_func) |
| Transposes the given tile distribution function for processes or devices.
|
|
bool | slate::func::is_2d_cyclic_grid (int64_t mt, int64_t nt, std::function< int(ij_tuple)> func, GridOrder *order, int *p, int *q) |
| Checks whether the given tile map is a 2d cyclic grid (i.e., equivalent to 'process_2d_grid(order, p, q)' for some 'order', 'p', and 'q').
|
|
Useful functions for SLATE's "lambda" constructors.
std::function< int(ij_tuple)> slate::func::device_1d_grid |
( |
GridOrder |
order, |
|
|
int64_t |
block_size, |
|
|
int |
size |
|
) |
| |
|
inline |
Distributes tiles to devices in a 1d block-cyclic fashion.
When the tiles are distributed across processes with process_2d_grid or process_1d_grid, this results in the local tiles being distributed cyclicly across devices.
This function can also be used to distribute tiles to processes, resulting in blocks of tiles belonging to the same process. However, the device grid should then be adjusted.
- Parameters
-
[in] | order | Col distributes a single column across multiple processes Row distributes a single row across multiple processes. |
[in] | block_size | The number of rows or columns in the process grid |
[in] | size | The number of rows or column in the device grid |
- Returns
- The distribution function
std::function< int(ij_tuple)> slate::func::device_2d_grid |
( |
GridOrder |
order, |
|
|
int64_t |
m, |
|
|
int64_t |
n, |
|
|
int64_t |
p, |
|
|
int64_t |
q |
|
) |
| |
|
inline |
Distributes tiles to devices in a 2d block-cyclic fashion.
When the tiles are distributed across processes with process_2d_grid, this results in the local tiles being distributed cyclicly across devices.
This function can also be used to distribute tiles to processes, resulting in blocks of tiles belonging to the same process. However, the device grid should then be adjusted.
- Parameters
-
[in] | order | Whether to use a column major or a row major grid |
[in] | p | The number of rows in the process grid |
[in] | q | The number of columns in the process grid |
[in] | p | The number of rows in the device grid |
[in] | q | The number of columns in the device grid |
- Returns
- The distribution function
std::function< int(ij_tuple)> slate::func::process_1d_grid |
( |
GridOrder |
order, |
|
|
int |
size |
|
) |
| |
|
inline |
Distributes tiles to processes in a 1d cyclic fashion, resulting in the elements being distributed in a 1d block-cyclic fashion.
This function can also be used to distribute tiles to devices in a 2d cyclic fashion, regardless of process ownership. Thus, care must be taken to prevent all of a process's tiles from being stored on a single device.
- Parameters
-
[in] | order | Col distributes a single column across multiple processes. Row distributes a single row across multiple processes. |
[in] | size | The number of processes |
- Returns
- The distribution function
std::function< int(ij_tuple)> slate::func::process_2d_grid |
( |
GridOrder |
order, |
|
|
int64_t |
p, |
|
|
int64_t |
q |
|
) |
| |
|
inline |
Distributes tiles to processes in a 2d cyclic fashion, resulting in the elements being distributed in a 2d block-cyclic fashion.
This function can also be used to distribute tiles to devices in a 2d cyclic fashion, regardless of process ownership. Thus, care must be taken to prevent all of a process's tiles from being stored on a single device.
- Parameters
-
[in] | order | Whether to use a column major or a row major grid |
[in] | p | The number of rows in the process grid |
[in] | q | The number of columns in the process grid |
- Returns
- The distribution function