ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность
9b91ac2fa3
openmpi/ompi/op/op_predefined.c

650 строки
22 KiB
C
Исходник Обычный вид История

First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
/*
Shame on me for not looking at the expanded collective datatype tables for the C++ bindings in MPI-2 p276-278 to see that MPI_BOOL should work with MPI_LAND, MPI_LOR, and MPI_LXOR. Thanks to Andy Selle for pointing this out. This commit was SVN r9200.
2006-03-04 21:35:33 +03:00
* Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
Update the copyright notices for IU and UTK. This commit was SVN r7999.
2005-11-05 22:57:48 +03:00
* University Research and Technology
* Corporation. All rights reserved.
MPI standard state that MPI_LONG_LONG and MPI_LONG_LONG_INT are synonyms. Thanks to Martin audet for finding out this one. This commit was SVN r9699.
2006-04-25 01:24:10 +04:00
* Copyright (c) 2004-2006 The University of Tennessee and The University
Update the copyright notices for IU and UTK. This commit was SVN r7999.
2005-11-05 22:57:48 +03:00
* of Tennessee Research Foundation. All rights
* reserved.
Add HLRS copyright This commit was SVN r3665.
2004-11-28 23:09:25 +03:00
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
Add UC copyright This commit was SVN r5009.
2005-03-24 15:43:37 +03:00
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
Drat -- forgot the copyright. This commit was SVN r10025.
2006-05-23 22:42:11 +04:00
* Copyright (c) 2006 Cisco Systems, Inc. All rights reserved.
First cut at copyrights: IU, UTK, and some OSU. LANL and HLRS still pending. This commit was SVN r3655.
2004-11-22 04:38:40 +03:00
* $COPYRIGHT$
*
* Additional copyrights may follow
*
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
* $HEADER$
*/
First pass of lam -> ompi conversion This commit was SVN r1191.
2004-06-07 19:33:53 +04:00
#include "ompi_config.h"
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
- Add #if protection around non-portable system .h files - Add #include "ompi_config.h" to all .c files, and ensure that it's the first #included file - remove a few useless #if HAVE_CONFIG_H checks This commit was SVN r3229.
2004-10-20 05:03:09 +04:00
#ifdef HAVE_SYS_TYPES_H
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#include <sys/types.h>
- Add #if protection around non-portable system .h files - Add #include "ompi_config.h" to all .c files, and ensure that it's the first #included file - remove a few useless #if HAVE_CONFIG_H checks This commit was SVN r3229.
2004-10-20 05:03:09 +04:00
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
Next step in the project split, mainly source code re-arranging - move files out of toplevel include/ and etc/, moving it into the sub-projects - rather than including config headers with <project>/include, have them as <project> - require all headers to be included with a project prefix, with the exception of the config headers ({opal,orte,ompi}_config.h mpi.h, and mpif.h) This commit was SVN r8985.
2006-02-12 04:33:29 +03:00
#include "ompi/op/op.h"
#include "ompi/op/op_predefined.h"
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*
* Since all the functions in this file are essentially identical, we
* use a macro to substitute in names and types. The core operation
* in all functions that use this macro is the same.
*
* This macro is for (out op in).
*/
#define OP_FUNC(name, type_name, type, op) \
void ompi_mpi_op_##name##_##type_name(void *in, void *out, int *count, \
MPI_Datatype *dtype) \
{ \
int i; \
type *a = (type *) in; \
type *b = (type *) out; \
for (i = 0; i < *count; ++i) { \
*(b++) op *(a++); \
} \
}
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#define COMPLEX_OP_FUNC_SUM(type_name, type) \
void ompi_mpi_op_sum_##type_name(void *in, void *out, int *count, \
MPI_Datatype *dtype) \
{ \
int i; \
type *a = (type *) in; \
type *b = (type *) out; \
for (i = 0; i < *count; ++i, ++b, ++a) { \
b->real += a->real; \
b->imag += a->imag; \
} \
}
#define COMPLEX_OP_FUNC_PROD(type_name, type) \
void ompi_mpi_op_prod_##type_name(void *in, void *out, int *count, \
MPI_Datatype *dtype) \
{ \
int i; \
type *a = (type *) in; \
type *b = (type *) out; \
type temp; \
for (i = 0; i < *count; ++i, ++b, ++a) { \
temp.real = a->real * b->real - a->imag * b->imag; \
temp.imag = a->imag * b->real + a->real * b->imag; \
*b = temp; \
} \
}
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*
* Since all the functions in this file are essentially identical, we
* use a macro to substitute in names and types. The core operation
* in all functions that use this macro is the same.
*
* This macro is for (out = op(out, in))
*/
#define FUNC_FUNC(name, type_name, type) \
void ompi_mpi_op_##name##_##type_name(void *in, void *out, int *count, \
MPI_Datatype *dtype) \
{ \
int i; \
type *a = (type *) in; \
type *b = (type *) out; \
for (i = 0; i < *count; ++i) { \
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
*(b) = current_func(*(b), *(a)); \
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
++b; \
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
++a; \
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
} \
}
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
/*
* Since all the functions in this file are essentially identical, we
* use a macro to substitute in names and types. The core operation
* in all functions that use this macro is the same.
*
* This macro is for minloc and maxloc
*/
#define LOC_STRUCT(type_name, type1, type2) \
typedef struct { \
type1 v; \
type2 k; \
} ompi_op_predefined_##type_name##_t;
#define LOC_FUNC(name, type_name, op) \
void ompi_mpi_op_##name##_##type_name(void *in, void *out, int *count, \
MPI_Datatype *dtype) \
{ \
int i; \
ompi_op_predefined_##type_name##_t *a = (ompi_op_predefined_##type_name##_t*) in; \
ompi_op_predefined_##type_name##_t *b = (ompi_op_predefined_##type_name##_t*) out; \
Fix a few more bugs with fortran collectives. This commit was SVN r2895.
2004-09-30 22:03:30 +04:00
for (i = 0; i < *count; ++i, ++a, ++b) { \
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
if (a->v op b->v) { \
LXOR is a logical xor not a bitwise one, so using the ^ operation is not correct. Advance the buffers for the *LOC operations. This commit was SVN r1721.
2004-07-14 23:16:13 +04:00
b->v = a->v; \
b->k = a->k; \
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
} else if (a->v == b->v) { \
b->k = (b->k < a->k ? b->k : a->k); \
} \
} \
}
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Max
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) > (b) ? (a) : (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(max, signed_char, signed char)
FUNC_FUNC(max, unsigned_char, unsigned char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(max, int, int)
FUNC_FUNC(max, long, long)
FUNC_FUNC(max, short, short)
FUNC_FUNC(max, unsigned_short, unsigned short)
FUNC_FUNC(max, unsigned, unsigned)
FUNC_FUNC(max, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(max, long_long_int, long long int)
FUNC_FUNC(max, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
FUNC_FUNC(max, fortran_integer, ompi_fortran_integer_t)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
FUNC_FUNC(max, fortran_integer1, ompi_fortran_integer1_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
FUNC_FUNC(max, fortran_integer2, ompi_fortran_integer2_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
FUNC_FUNC(max, fortran_integer4, ompi_fortran_integer4_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
FUNC_FUNC(max, fortran_integer8, ompi_fortran_integer8_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
FUNC_FUNC(max, fortran_integer16, ompi_fortran_integer16_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Floating point */
FUNC_FUNC(max, float, float)
FUNC_FUNC(max, double, double)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(max, fortran_real, ompi_fortran_real_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
FUNC_FUNC(max, fortran_double_precision, ompi_fortran_double_precision_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(max, long_double, long double)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_REAL4
FUNC_FUNC(max, fortran_real4, ompi_fortran_real4_t)
#endif
#if OMPI_HAVE_FORTRAN_REAL8
FUNC_FUNC(max, fortran_real8, ompi_fortran_real8_t)
#endif
#if OMPI_HAVE_FORTRAN_REAL16
FUNC_FUNC(max, fortran_real16, ompi_fortran_real16_t)
#endif
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Min
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) < (b) ? (a) : (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(min, signed_char, signed char)
FUNC_FUNC(min, unsigned_char, unsigned char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(min, int, int)
FUNC_FUNC(min, long, long)
FUNC_FUNC(min, short, short)
FUNC_FUNC(min, unsigned_short, unsigned short)
FUNC_FUNC(min, unsigned, unsigned)
FUNC_FUNC(min, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(min, long_long_int, long long int)
FUNC_FUNC(min, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
FUNC_FUNC(min, fortran_integer, ompi_fortran_integer_t)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
FUNC_FUNC(min, fortran_integer1, ompi_fortran_integer1_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
FUNC_FUNC(min, fortran_integer2, ompi_fortran_integer2_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
FUNC_FUNC(min, fortran_integer4, ompi_fortran_integer4_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
FUNC_FUNC(min, fortran_integer8, ompi_fortran_integer8_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
FUNC_FUNC(min, fortran_integer16, ompi_fortran_integer16_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Floating point */
FUNC_FUNC(min, float, float)
FUNC_FUNC(min, double, double)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(min, fortran_real, ompi_fortran_real_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
FUNC_FUNC(min, fortran_double_precision, ompi_fortran_double_precision_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(min, long_double, long double)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_REAL4
FUNC_FUNC(min, fortran_real4, ompi_fortran_real4_t)
#endif
#if OMPI_HAVE_FORTRAN_REAL8
FUNC_FUNC(min, fortran_real8, ompi_fortran_real8_t)
#endif
#if OMPI_HAVE_FORTRAN_REAL16
FUNC_FUNC(min, fortran_real16, ompi_fortran_real16_t)
#endif
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Sum
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
OP_FUNC(sum, signed_char, signed char, +=)
OP_FUNC(sum, unsigned_char, unsigned char, +=)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(sum, int, int, +=)
OP_FUNC(sum, long, long, +=)
OP_FUNC(sum, short, short, +=)
OP_FUNC(sum, unsigned_short, unsigned short, +=)
OP_FUNC(sum, unsigned, unsigned, +=)
OP_FUNC(sum, unsigned_long, unsigned long, +=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
OP_FUNC(sum, long_long_int, long long int, +=)
OP_FUNC(sum, unsigned_long_long, unsigned long long, +=)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
OP_FUNC(sum, fortran_integer, ompi_fortran_integer_t, +=)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
OP_FUNC(sum, fortran_integer1, ompi_fortran_integer1_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
OP_FUNC(sum, fortran_integer2, ompi_fortran_integer2_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
OP_FUNC(sum, fortran_integer4, ompi_fortran_integer4_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
OP_FUNC(sum, fortran_integer8, ompi_fortran_integer8_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
OP_FUNC(sum, fortran_integer16, ompi_fortran_integer16_t, +=)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Floating point */
OP_FUNC(sum, float, float, +=)
OP_FUNC(sum, double, double, +=)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(sum, fortran_real, ompi_fortran_real_t, +=)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
OP_FUNC(sum, fortran_double_precision, ompi_fortran_double_precision_t, +=)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(sum, long_double, long double, +=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_REAL4
OP_FUNC(sum, fortran_real4, ompi_fortran_real4_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_REAL8
OP_FUNC(sum, fortran_real8, ompi_fortran_real8_t, +=)
#endif
#if OMPI_HAVE_FORTRAN_REAL16
OP_FUNC(sum, fortran_real16, ompi_fortran_real16_t, +=)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Complex */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_SUM(fortran_complex, ompi_fortran_complex_t)
Correct a few #if issues that George identified in a code review This commit was SVN r7724.
2005-10-12 17:19:46 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
Add support for MPI_OP_SUM, PROD, REPLACE with MPI_DOUBLE_COMPLEX. Need to consult with George -- might also need to add support for complex types on floats or long doubles... This commit was SVN r7716.
2005-10-12 06:31:28 +04:00
COMPLEX_OP_FUNC_SUM(fortran_double_complex, ompi_fortran_double_complex_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_SUM(fortran_complex8, ompi_fortran_complex8_t)
#endif
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_SUM(fortran_complex16, ompi_fortran_complex16_t)
#endif
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_SUM(fortran_complex32, ompi_fortran_complex32_t)
#endif
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Product
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
OP_FUNC(prod, signed_char, signed char, *=)
OP_FUNC(prod, unsigned_char, unsigned char, *=)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(prod, int, int, *=)
OP_FUNC(prod, long, long, *=)
OP_FUNC(prod, short, short, *=)
OP_FUNC(prod, unsigned_short, unsigned short, *=)
OP_FUNC(prod, unsigned, unsigned, *=)
OP_FUNC(prod, unsigned_long, unsigned long, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, long_long_int, long long int, *=)
OP_FUNC(prod, unsigned_long_long, unsigned long long, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
OP_FUNC(prod, fortran_integer, ompi_fortran_integer_t, *=)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
@#$%@#%#% Fix one more typo that was missed last night. This commit was SVN r10038.
2006-05-24 14:30:08 +04:00
OP_FUNC(prod, fortran_integer1, ompi_fortran_integer1_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_integer2, ompi_fortran_integer2_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_integer4, ompi_fortran_integer4_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_integer8, ompi_fortran_integer8_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_integer16, ompi_fortran_integer16_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Floating point */
OP_FUNC(prod, float, float, *=)
OP_FUNC(prod, double, double, *=)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(prod, fortran_real, ompi_fortran_real_t, *=)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
OP_FUNC(prod, fortran_double_precision, ompi_fortran_double_precision_t, *=)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
OP_FUNC(prod, long_double, long double, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_REAL4
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_real4, ompi_fortran_real4_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_REAL8
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_real8, ompi_fortran_real8_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
#if OMPI_HAVE_FORTRAN_REAL16
Unbelieveable how this lived so long. Thanks to Bert Wesarg for reporting this. This commit was SVN r10023.
2006-05-23 22:00:44 +04:00
OP_FUNC(prod, fortran_real16, ompi_fortran_real16_t, *=)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Complex */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_PROD(fortran_complex, ompi_fortran_complex_t)
Correct a few #if issues that George identified in a code review This commit was SVN r7724.
2005-10-12 17:19:46 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
Add support for MPI_OP_SUM, PROD, REPLACE with MPI_DOUBLE_COMPLEX. Need to consult with George -- might also need to add support for complex types on floats or long doubles... This commit was SVN r7716.
2005-10-12 06:31:28 +04:00
COMPLEX_OP_FUNC_PROD(fortran_double_complex, ompi_fortran_double_complex_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_PROD(fortran_complex8, ompi_fortran_complex8_t)
#endif
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_PROD(fortran_complex16, ompi_fortran_complex16_t)
#endif
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
COMPLEX_OP_FUNC_PROD(fortran_complex32, ompi_fortran_complex32_t)
#endif
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Logical AND
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) && (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(land, unsigned_char, unsigned char)
FUNC_FUNC(land, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(land, int, int)
FUNC_FUNC(land, long, long)
FUNC_FUNC(land, short, short)
FUNC_FUNC(land, unsigned_short, unsigned short)
FUNC_FUNC(land, unsigned, unsigned)
FUNC_FUNC(land, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(land, long_long_int, long long int)
FUNC_FUNC(land, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Logical */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_LOGICAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(land, fortran_logical, ompi_fortran_logical_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
Shame on me for not looking at the expanded collective datatype tables for the C++ bindings in MPI-2 p276-278 to see that MPI_BOOL should work with MPI_LAND, MPI_LOR, and MPI_LXOR. Thanks to Andy Selle for pointing this out. This commit was SVN r9200.
2006-03-04 21:35:33 +03:00
/* C++ bool */
FUNC_FUNC(land, bool, bool)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Logical OR
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) || (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(lor, unsigned_char, unsigned char)
FUNC_FUNC(lor, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(lor, int, int)
FUNC_FUNC(lor, long, long)
FUNC_FUNC(lor, short, short)
FUNC_FUNC(lor, unsigned_short, unsigned short)
FUNC_FUNC(lor, unsigned, unsigned)
FUNC_FUNC(lor, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(lor, long_long_int, long long int)
FUNC_FUNC(lor, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Logical */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_LOGICAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(lor, fortran_logical, ompi_fortran_logical_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
Shame on me for not looking at the expanded collective datatype tables for the C++ bindings in MPI-2 p276-278 to see that MPI_BOOL should work with MPI_LAND, MPI_LOR, and MPI_LXOR. Thanks to Andy Selle for pointing this out. This commit was SVN r9200.
2006-03-04 21:35:33 +03:00
/* C++ bool */
FUNC_FUNC(lor, bool, bool)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Logical XOR
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
LXOR is a logical xor not a bitwise one, so using the ^ operation is not correct. Advance the buffers for the *LOC operations. This commit was SVN r1721.
2004-07-14 23:16:13 +04:00
#define current_func(a, b) ((a ? 1 : 0) ^ (b ? 1: 0))
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(lxor, unsigned_char, unsigned char)
FUNC_FUNC(lxor, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(lxor, int, int)
FUNC_FUNC(lxor, long, long)
FUNC_FUNC(lxor, short, short)
FUNC_FUNC(lxor, unsigned_short, unsigned short)
FUNC_FUNC(lxor, unsigned, unsigned)
FUNC_FUNC(lxor, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(lxor, long_long_int, long long int)
FUNC_FUNC(lxor, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Logical */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_LOGICAL
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(lxor, fortran_logical, ompi_fortran_logical_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
Shame on me for not looking at the expanded collective datatype tables for the C++ bindings in MPI-2 p276-278 to see that MPI_BOOL should work with MPI_LAND, MPI_LOR, and MPI_LXOR. Thanks to Andy Selle for pointing this out. This commit was SVN r9200.
2006-03-04 21:35:33 +03:00
/* C++ bool */
FUNC_FUNC(lxor, bool, bool)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Bitwise AND
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) & (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(band, unsigned_char, unsigned char)
FUNC_FUNC(band, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(band, int, int)
FUNC_FUNC(band, long, long)
FUNC_FUNC(band, short, short)
FUNC_FUNC(band, unsigned_short, unsigned short)
FUNC_FUNC(band, unsigned, unsigned)
FUNC_FUNC(band, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(band, long_long_int, long long int)
FUNC_FUNC(band, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
FUNC_FUNC(band, fortran_integer, ompi_fortran_integer_t)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
FUNC_FUNC(band, fortran_integer1, ompi_fortran_integer1_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
FUNC_FUNC(band, fortran_integer2, ompi_fortran_integer2_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
FUNC_FUNC(band, fortran_integer4, ompi_fortran_integer4_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
FUNC_FUNC(band, fortran_integer8, ompi_fortran_integer8_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
FUNC_FUNC(band, fortran_integer16, ompi_fortran_integer16_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Byte */
FUNC_FUNC(band, byte, char)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Bitwise OR
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) | (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(bor, unsigned_char, unsigned char)
FUNC_FUNC(bor, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(bor, int, int)
FUNC_FUNC(bor, long, long)
FUNC_FUNC(bor, short, short)
FUNC_FUNC(bor, unsigned_short, unsigned short)
FUNC_FUNC(bor, unsigned, unsigned)
FUNC_FUNC(bor, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(bor, long_long_int, long long int)
FUNC_FUNC(bor, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
FUNC_FUNC(bor, fortran_integer, ompi_fortran_integer_t)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
FUNC_FUNC(bor, fortran_integer1, ompi_fortran_integer1_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
FUNC_FUNC(bor, fortran_integer2, ompi_fortran_integer2_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
FUNC_FUNC(bor, fortran_integer4, ompi_fortran_integer4_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
FUNC_FUNC(bor, fortran_integer8, ompi_fortran_integer8_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
FUNC_FUNC(bor, fortran_integer16, ompi_fortran_integer16_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Byte */
FUNC_FUNC(bor, byte, char)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/*************************************************************************
* Bitwise XOR
*************************************************************************/
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
#undef current_func
#define current_func(a, b) ((a) ^ (b))
/* C integer */
- Allow MPI_UNSIGNED_CHAR and MPI_SIGNED_CHAR for Reduction operations as described by MPI2, p77. This commit was SVN r9229.
2006-03-09 19:51:59 +03:00
FUNC_FUNC(bxor, unsigned_char, unsigned char)
FUNC_FUNC(bxor, signed_char, signed char)
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
FUNC_FUNC(bxor, int, int)
FUNC_FUNC(bxor, long, long)
FUNC_FUNC(bxor, short, short)
FUNC_FUNC(bxor, unsigned_short, unsigned short)
FUNC_FUNC(bxor, unsigned, unsigned)
FUNC_FUNC(bxor, unsigned_long, unsigned long)
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if HAVE_LONG_LONG
FUNC_FUNC(bxor, long_long_int, long long int)
FUNC_FUNC(bxor, unsigned_long_long, unsigned long long)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Fortran integer */
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER
FUNC_FUNC(bxor, fortran_integer, ompi_fortran_integer_t)
#endif
A bunch of changes to support MPI_INTEGER*x, MPI_REAL*x, MPI_COMPLEX*x, and some optional C datatypes in MPI reduction operations. These types are not technically supported by the letter of the MPI standard, but are implied by the spirit of it (and there are definitely users that use them in real applications) - Add checks in configure for back-end C types for MPI_INTEGER*x and MPI_REAL*x - Create C data structs for MPI_COMPLEX*x - Fixed typo for MPI_INTEGER8 in mpi.h - Updated configure macros to create MPI_FORTRAN_INTEGER* defines, as opposed to MPI_FORTRAN_INT, which was causing [me] lots of confusion (between C "*_INT" names and Fortran "*_INT" names). This caused some trivial updates in ddt, ompi_info, and the MPI layer to match. - Update ompi_info to show whether we have each MPI_INTEGER*x, MPI_REAL*x, and MPI_COMPLEX*x - Extended reduction operations for optional datatypes: - "C integer" now includes long long int, long long, and unsigned long long - "Fortran integer" now includes MPI_INTEGER*x - "Floating point" now includes MPI_REAL*x - "Complex" now includes MPI_COMPLEX*x This commit was SVN r5511.
2005-04-27 14:23:06 +04:00
#if OMPI_HAVE_FORTRAN_INTEGER1
FUNC_FUNC(bxor, fortran_integer1, ompi_fortran_integer1_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER2
FUNC_FUNC(bxor, fortran_integer2, ompi_fortran_integer2_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER4
FUNC_FUNC(bxor, fortran_integer4, ompi_fortran_integer4_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER8
FUNC_FUNC(bxor, fortran_integer8, ompi_fortran_integer8_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER16
FUNC_FUNC(bxor, fortran_integer16, ompi_fortran_integer16_t)
#endif
Lots of changes in this commit, mostly having to do with the first real commit of the collectives. MPI_SCAN and MPI_EXSCAN are still not implemented, but lots of other things are in the critical path and holding up other people, so it's ok to commit without them: - better checks for sizes in configure, and add defaults for fortran sizes if we don't have a fortran compiler - fix some logic that was accidentally broken for size checks for the file type offset_t - add some C equivalent types for fortran's complex and double complex (for use in internal reduction/op functions) - additionals and slight reorganization of ompi_mpi_init() ompi_mpi_finalize() - fully implement all top-level MPI collective calls, including all param checking for both intra- and inter-communicators (woof) - change the communicator_t type for stuff that we need in coll, and update all references throughout the code base to match - all kinds of updates to the coll framework base - next cut of the basic coll module -- has all intracommunicator collectives implemented except scan and exscan (see note above). All intercommunicator functions return ERR_NOT_IMPLEMENTED. - MPI_Op is a fixed implementation -- not component-ized yet. So there are generic C loops for all implementations. This commit was SVN r1491.
2004-06-29 04:02:25 +04:00
/* Byte */
FUNC_FUNC(bxor, byte, char)
First cut of op handling -- now link-compatible. Still have work to be done: - need to define internal op_create function (that MPI_OP_CREATE will call) - need to fill in all the handler functions that are the back-ends to the intrinsic MPI operations (e.g., MPI_SUM, MPI_MAX, etc.) This commit was SVN r1061.
2004-04-21 02:37:46 +04:00
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
/*************************************************************************
* Min and max location "pair" datatypes
*************************************************************************/
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_STRUCT(2real, ompi_fortran_real_t, ompi_fortran_real_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
LOC_STRUCT(2double_precision, ompi_fortran_double_precision_t, ompi_fortran_double_precision_t)
#endif
#if OMPI_HAVE_FORTRAN_INTEGER
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_STRUCT(2integer, ompi_fortran_integer_t, ompi_fortran_integer_t)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_STRUCT(float_int, float, int)
LOC_STRUCT(double_int, double, int)
LOC_STRUCT(long_int, long, int)
LOC_STRUCT(2int, int, int)
Fix some minor errors in the predefined MPI_Op's This commit was SVN r2880.
2004-09-30 01:08:29 +04:00
LOC_STRUCT(short_int, short, int)
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_STRUCT(long_double_int, long double, int)
/*************************************************************************
* Max location
*************************************************************************/
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(maxloc, 2real, >)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(maxloc, 2double_precision, >)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(maxloc, 2integer, >)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(maxloc, float_int, >)
LOC_FUNC(maxloc, double_int, >)
LOC_FUNC(maxloc, long_int, >)
LOC_FUNC(maxloc, 2int, >)
LOC_FUNC(maxloc, short_int, >)
LOC_FUNC(maxloc, long_double_int, >)
/*************************************************************************
* Min location
*************************************************************************/
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#if OMPI_HAVE_FORTRAN_REAL
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(minloc, 2real, <)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(minloc, 2double_precision, <)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
#if OMPI_HAVE_FORTRAN_INTEGER
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(minloc, 2integer, <)
Bunches of fixes for Fortran support: - Fully support REAL*N, INTEGER*N, and COMPLEX*N in the MPI_Op reduction operations. - Update ddt to fully support these types as well, to include using the results of sizes and alignments determined by configure - Discover the goodness of m4 and consolidate a LOT of configure code (i.e., remove a lot of essentially duplicated code and m4-subroutine-ize it). The big kicker was figuring out how to parameterize AC_DEFINE_UNQUOTED, which you can do if you use m4 properly. - If we don't support a given INTEGER*N, REAL*N, or COMPLEX*N, don't error. Just set the right flags so that we don't support them in the MPI layer. This commit was SVN r5788.
2005-05-20 03:56:02 +04:00
#endif
- Code review by George; fix some minor errors - Add MINLOC and MAXLOC - Add REPLACE This commit was SVN r1672.
2004-07-13 19:20:46 +04:00
LOC_FUNC(minloc, float_int, <)
LOC_FUNC(minloc, double_int, <)
LOC_FUNC(minloc, long_int, <)
LOC_FUNC(minloc, 2int, <)
LOC_FUNC(minloc, short_int, <)
LOC_FUNC(minloc, long_double_int, <)
Копировать постоянную ссылку