diff options
Diffstat (limited to 'src/ReductionSum.c')
-rw-r--r-- | src/ReductionSum.c | 261 |
1 files changed, 261 insertions, 0 deletions
diff --git a/src/ReductionSum.c b/src/ReductionSum.c new file mode 100644 index 0000000..e04dc36 --- /dev/null +++ b/src/ReductionSum.c @@ -0,0 +1,261 @@ + /*@@ + @file ReductionSum.c + @date Thu Apr 3 11:54:53 1997 + @author Thomas Radke, Paul Walker + @desc + Defines the PUGH reduction operator to get the sum + of an arbitrary array. + @enddesc + @version $Id$ + @@*/ + +#include <stdlib.h> +#include <string.h> + +#include "local_reductions.h" + +static const char *rcsid = "$Id$"; + +CCTK_FILEVERSION(CCTDevelopment_LocalReduce_ReductionSum_c) + +/* local function prototypes */ +static int ReductionSum (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void *const output_numbers[]); + + +/*@@ + @routine ReductionSumArrays + @author Thomas Radke + @date 19 Aug 1999 + @desc + Registered PUGH reduction routine for computing the sums + of a set of arrays. + The arrays are described by their dimensions and variable type. + For the number of output values only 1 is accepted. + Type casting of the result is provided by specifying the + requested output datatype. The intermediate reduction value + is always computed as a CCTK_REAL value internally. + @enddesc + @history + @endhistory + @var GH + @vdesc Pointer to CCTK grid hierarchy + @vtype const cGH * + @vio in + @endvar + @var proc + @vdesc processor that should receive the result of operation + (negative value means all processors receive the result) + @vtype int + @vio in + @endvar + @var nDims + @vdesc number of dimensions of input arrays + @vtype int + @vio in + @endvar + @var dims + @vdesc dimensions of input arrays + @vtype const int * + @vio in + @endvar + @var nArrays + @vdesc number of input arrays + @vtype int + @vio in + @endvar + @var input_arrays + @vdesc field of input arrays + @vtype const void *const + @vio in + @endvar + @var inType + @vdesc (common) variable type of input arrays + @vtype int + @vio in + @endvar + @var num_outvals + @vdesc number of values per output array + @vtype int + @vio in + @endvar + @var outvals + @vdesc pointer to buffer holding the output values + @vtype void * + @vio in + @endvar + @var outtype + @vdesc (common) variable type of output arrays + @vtype int + @vio in + @endvar +@@*/ +int ReductionSumArrays (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void *const output_numbers[]) +{ + return (ReductionSum (N_dims, operator_handle, + param_table_handle, N_input_arrays, + input_array_dims, input_array_type_codes, + input_arrays, M_output_numbers, + output_number_type_codes, output_numbers)); +} + + +/*****************************************************************************/ +/* local functions */ +/*****************************************************************************/ +/*@@ + @routine ReductionSum + @date Aug 19 1999 + @author Thomas Radke + @desc Returns the sum of a distributed array with + 'num_points' elements. Global reduction is done element-wise + (num_outvals == 1) or on the results of the local reductions. + @enddesc +@@*/ +static int ReductionSum (int N_dims, int operator_handle, + int param_table_handle, int N_input_arrays, + const CCTK_INT input_array_dims[], + const CCTK_INT input_array_type_codes[], + const void *const input_arrays[], + int M_output_numbers, + const CCTK_INT output_number_type_codes[], + void *const output_numbers[]) +{ + int i, total_outvals; + const char *vtypename; + + +/* macros to complete the ITERATE_ARRAY macro */ +#define INITIAL_REDUCTION_VALUE(array) 0 +#define REDUCTION_OPERATION(sum, scalar) sum += scalar + + int from3D[3], to3D[3]; + int from2D[2], to2D[2]; + int from1D[1], to1D[1]; + + from3D[0]=0; + from3D[1]=0; + from3D[2]=0; + + from2D[0]=0; + from2D[1]=0; + + from1D[0]=0; + + to3D[0]=10; + to3D[1]=10; + to3D[2]=10; + + to2D[0]=10; + to2D[1]=10; + + to31[0]=10; + + for (i = total_outvals = 0; i < N_input_arrays; i++) + { + switch (input_array_type_codes[i]) + { + case CCTK_VARIABLE_CHAR: + ITERATE_ARRAY (CCTK_BYTE, input_array_dims[i], input_arrays[i], + from3D, to3D, iterator, points_per_dim, + CCTK_BYTE, output_numbers, num_outvals, total_outvals); + break; + + case CCTK_VARIABLE_INT: + ITERATE_ARRAY (CCTK_INT, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_INT, outvals, num_outvals, total_outvals); + break; + +#ifdef CCTK_INT1 + case CCTK_VARIABLE_INT1: + ITERATE_ARRAY (CCTK_INT1, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_INT1, outvals, num_outvals, total_outvals); + break; +#endif + +#ifdef CCTK_INT2 + case CCTK_VARIABLE_INT2: + ITERATE_ARRAY (CCTK_INT2, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_INT2, outvals, num_outvals, total_outvals); + break; +#endif + +#ifdef CCTK_INT4 + case CCTK_VARIABLE_INT4: + ITERATE_ARRAY (CCTK_INT4, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_INT4, outvals, num_outvals, total_outvals); + break; +#endif + +#ifdef CCTK_INT8 + case CCTK_VARIABLE_INT8: + ITERATE_ARRAY (CCTK_INT8, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_INT8, outvals, num_outvals, total_outvals); + break; +#endif + + case CCTK_VARIABLE_REAL: + ITERATE_ARRAY (CCTK_REAL, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_REAL, outvals, num_outvals, total_outvals); + break; + +#ifdef CCTK_REAL4 + case CCTK_VARIABLE_REAL4: + ITERATE_ARRAY (CCTK_REAL4, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_REAL4, outvals, num_outvals, total_outvals); + break; +#endif + +#ifdef CCTK_REAL8 + case CCTK_VARIABLE_REAL8: + ITERATE_ARRAY (CCTK_REAL8, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_REAL8, outvals, num_outvals, total_outvals); + break; +#endif + +#ifdef CCTK_REAL16 + case CCTK_VARIABLE_REAL16: + ITERATE_ARRAY (CCTK_REAL16, num_dims, input_arrays[i], + from, to, iterator, points_per_dim, + CCTK_REAL16, outvals, num_outvals, total_outvals); + break; +#endif + + default: + vtypename = CCTK_VarTypeName (input_array_type_codes[i]); + if (vtypename && strncmp (vtypename, "CCTK_VARIABLE_COMPLEX", 21) == 0) + { + CCTK_WARN (1, "ReductionSum: Don't know how to compute " + "the sum of complex variables !!!"); + } + else + { + CCTK_WARN (1, "ReductionSum: Unknown variable type"); + } + return (-1); + } + } + + return (0); +} |