cs_parall.c File Reference

#include "cs_defs.h"
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "bft_error.h"
#include "bft_mem.h"
#include "cs_order.h"
#include "cs_parall.h"

Include dependency graph for cs_parall.c:

Functions
void	cs_parall_max_loc_vals (int n, cs_real_t *max, cs_real_t max_loc_vals[])
	Maximum value of a real and the value of related array on all default communicator processes. More...
void	cs_parall_min_loc_vals (int n, cs_real_t *min, cs_real_t min_loc_vals[])
	Minimum value of a real and the value of related array on all default communicator processes. More...
void	cs_parall_min_id_rank_r (cs_lnum_t *elt_id, int *rank_id, cs_real_t val)
	Given an (id, rank, value) tuple, return the local id and rank corresponding to the global minimum value. More...
void	cs_parall_allgather_r (int n_elts, int n_g_elts, cs_real_t array[], cs_real_t g_array[])
	Build a global array from each local array in each domain. More...
void	cs_parall_allgather_ordered_r (int n_elts, int n_g_elts, int stride, cs_real_t o_key[], cs_real_t array[], cs_real_t g_array[])
	Build an ordered global array from each local array in each domain. More...
void	cs_parall_gather_r (int root_rank, int n_elts, int n_g_elts, const cs_real_t array[], cs_real_t g_array[])
	Build a global array on the given root rank from all local arrays. More...
void	cs_parall_gather_ordered_r (int root_rank, int n_elts, int n_g_elts, int stride, cs_real_t o_key[], cs_real_t array[], cs_real_t g_array[])
	Build an ordered global array on the given root rank from all local arrays. More...
void	cs_parall_scatter_r (int root_rank, int n_elts, int n_g_elts, const cs_real_t g_array[], cs_real_t array[])
	Distribute a global array from a given root rank over all ranks. Each rank receive the part related to its local elements. More...
void	cs_parall_gather_f (int root_rank, int n_elts, int n_g_elts, const float array[], float g_array[])
	Build a global array on the given root rank from all local arrays. Function dealing with single-precision arrays. More...
void	cs_parall_scatter_f (int root_rank, int n_elts, int n_g_elts, const float g_array[], float array[])
	Distribute a global array from a given root rank over all ranks. Each rank receive the part related to its local elements. Function dealing with single-precision arrays. More...
size_t	cs_parall_get_min_coll_buf_size (void)
	Return minimum recommended scatter or gather buffer size. More...
void	cs_parall_set_min_coll_buf_size (size_t buffer_size)
	Define minimum recommended scatter or gather buffer size. More...

Detailed Description

Utility functions dealing with parallelism.

Function Documentation

cs_parall_allgather_ordered_r()

void cs_parall_allgather_ordered_r	(	int	n_elts,
		int	n_g_elts,
		int	stride,
		cs_real_t	o_key[],
		cs_real_t	array[],
		cs_real_t	g_array[]
	)

Build an ordered global array from each local array in each domain.

Local array elements are ordered based on a given key value (usually some form of coordinate, so the result should be independent of partitioning as long as the definition of the o_key array's defintion is itself independent of the partitioning.

Use of this function may be quite practical, but should be limited to user functions, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	n_elts	number of local elements
[in]	n_g_elts	number of global elements
[in]	stride	number of values per element
[in]	o_key	ordering key (coordinate) value per element
[in]	array	local array (size: n_elts*stride)
[out]	g_array	global array (size: n_g_elts*stride)

cs_parall_allgather_r()

void cs_parall_allgather_r	(	int	n_elts,
		int	n_g_elts,
		cs_real_t	array[],
		cs_real_t	g_array[]
	)

Build a global array from each local array in each domain.

Local arrays are appended in order of owning MPI rank. The size of each local array may be different.

Use of this function may be quite practical, but should be limited to user functions, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	n_elts	size of the local array
[in]	n_g_elts	size of the global array
[in]	array	local array (size: n_elts)
[out]	g_array	global array (size: n_g_elts)

cs_parall_gather_f()

void cs_parall_gather_f	(	int	root_rank,
		int	n_elts,
		int	n_g_elts,
		const float	array[],
		float	g_array[]
	)

Build a global array on the given root rank from all local arrays. Function dealing with single-precision arrays.

Local arrays are appended in order of owning MPI rank. The size of each local array may be different.

Use of this function may be quite practical, but should be limited to user functions, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	root_rank	rank which stores the global array
[in]	n_elts	size of the local array
[in]	n_g_elts	size of the global array
[in]	array	local array (size: n_elts)
[out]	g_array	global array (size: n_g_elts) only usable by the root rank

cs_parall_gather_ordered_r()

void cs_parall_gather_ordered_r	(	int	root_rank,
		int	n_elts,
		int	n_g_elts,
		int	stride,
		cs_real_t	o_key[],
		cs_real_t	array[],
		cs_real_t	g_array[]
	)

Build an ordered global array on the given root rank from all local arrays.

Local array elements are ordered based on a given key value (usually some form of coordinate, so the result should be independent of partitioning as long as the definition of the o_key array's defintion is itself independent of the partitioning.

Use of this function may be quite practical, but should be limited to user functions, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	root_rank	rank which stores the global array
[in]	n_elts	number of local elements
[in]	n_g_elts	number of global elements
[in]	stride	number of values per element
[in]	o_key	ordering key (coordinate) value per element
[in]	array	local array (size: n_elts*stride)
[out]	g_array	global array (size: n_g_elts*stride)

cs_parall_gather_r()

void cs_parall_gather_r	(	int	root_rank,
		int	n_elts,
		int	n_g_elts,
		const cs_real_t	array[],
		cs_real_t	g_array[]
	)

Build a global array on the given root rank from all local arrays.

Local arrays are appended in order of owning MPI rank. The size of each local array may be different.

Use of this function may be quite practical, but should be limited to user functions, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	root_rank	rank which stores the global array
[in]	n_elts	size of the local array
[in]	n_g_elts	size of the global array
[in]	array	local array (size: n_elts)
[out]	g_array	global array (size: n_g_elts) only usable by the root rank

cs_parall_get_min_coll_buf_size()

size_t cs_parall_get_min_coll_buf_size

(

void

)

Return minimum recommended scatter or gather buffer size.

This is used by some internal part to block or scatter/gather algorithms, so as to allow I/O buffer size tuning.

Returns

minimum recommended part to block or gather buffer size (in bytes)

cs_parall_max_loc_vals()

void cs_parall_max_loc_vals	(	int	n,
		cs_real_t *	max,
		cs_real_t	max_loc_vals[]
	)

Maximum value of a real and the value of related array on all default communicator processes.

Parameters

[in]	n	size of the related array
[in,out]	max	local max in, global max out
[in,out]	max_loc_vals	array values at location of local max in, and at location of global max out

cs_parall_min_id_rank_r()

void cs_parall_min_id_rank_r	(	cs_lnum_t *	elt_id,
		int *	rank_id,
		cs_real_t	val
	)

Given an (id, rank, value) tuple, return the local id and rank corresponding to the global minimum value.

Parameters

[in,out]	elt_id	element id for which the value is the smallest (local in, global out)
[in,out]	rank_id	rank id for which the value is the smallest (local in, global out)
[in]	val	associated local minimum value

cs_parall_min_loc_vals()

void cs_parall_min_loc_vals	(	int	n,
		cs_real_t *	min,
		cs_real_t	min_loc_vals[]
	)

Minimum value of a real and the value of related array on all default communicator processes.

Parameters

[in]	n	size of the related array
[in,out]	min	local min in, global min out
[in,out]	min_loc_vals	array values at location of local min in, and at location of global min out

cs_parall_scatter_f()

void cs_parall_scatter_f	(	int	root_rank,
		int	n_elts,
		int	n_g_elts,
		const float	g_array[],
		float	array[]
	)

Distribute a global array from a given root rank over all ranks. Each rank receive the part related to its local elements. Function dealing with single-precision arrays.

The size of each local array may be different.

Use of this function may be quite practical, but should be limited to specific usage, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	root_rank	rank which stores the global array
[in]	n_elts	size of the local array
[in]	n_g_elts	size of the global array
[in]	g_array	global array (size: n_g_elts) only usable by the root rank
[out]	array	local array (size: n_elts)

cs_parall_scatter_r()

void cs_parall_scatter_r	(	int	root_rank,
		int	n_elts,
		int	n_g_elts,
		const cs_real_t	g_array[],
		cs_real_t	array[]
	)

Distribute a global array from a given root rank over all ranks. Each rank receive the part related to its local elements.

The size of each local array may be different.

Use of this function may be quite practical, but should be limited to specific usage, as it may limit scalability (especially as regards memory usage).

Parameters

[in]	root_rank	rank which stores the global array
[in]	n_elts	size of the local array
[in]	n_g_elts	size of the global array
[in]	g_array	global array (size: n_g_elts) only usable by the root rank
[out]	array	local array (size: n_elts)

cs_parall_set_min_coll_buf_size()

void cs_parall_set_min_coll_buf_size

(

size_t

buffer_size

)

Define minimum recommended scatter or gather buffer size.

This is used by some internal part to block or scatter/gather algorithms, so as to allow I/O buffer size tuning.

Parameters

[in]

buffer_size

minimum recommended part to block or gather buffer size (in bytes)