SQUASH_ME: OMNIBUS 2

ompi-codegen.patch from dalcinl
ompi-abiinfo.patch from dalcinl
ompi-status.patch from dalcinl
fixes to setting/getting status fields and some more
move some deprecated funcs out of libmpi-abi
add support for typeclass
ops: convert data from internal to abi
for user ops
split rdma modes out from modes for files

the ompi internal rdma and file mode bits overlap,
so we need to treat them that way in the bindings
generation code too.

add SOURCE_ARRAY type

to help out MPI_Group_translate_ranks

fixes to abi_get_fortran_info

for logicals

apply patch omp-op-inout.patch

from dalcinl

apply patch ompi-abi-fortran.patch

from dalcinl

fix for FD_INOUT

fix for isend dst arg

needs to go through translation

apply patch ompi-query-thread.patch

from dalcinl

various pt2pt fixes to handle proc_null etc.

eventually we'll use separate SOURCE and DEST (or something like that)
types.

rma: updates to args to handle proc_null etc

adjustments for improbe and iprobe

fix for status array for MPI_Request_testsome

switch to using a malloc wrapper

per dalcinl suggestion

plug memory leak handling REQUEST_INOUT type

patch status out to handle copy in

there are many functions where a status is conditionally
returned.  Trying to treat each of these would be too
complex so instead copy contents of the status supplied as
input into any temporary status variables then copy back
out.

handle dargs for darray_create correctly

fixes for spawn multiple - array of info args

and array of errorcodes

disable async NBC-based cleanup for now
turn back on async array cleanup stuff
and add a check that the returned request isn't
complete.

Signed-off-by: Howard Pritchard <[email protected]>

Author: hppritcha

ompi/datatype/ompi_datatype_internal.h

@@ -393,6 +393,28 @@
 #  define OMPI_DATATYPE_MPI_REAL16                OMPI_DATATYPE_MPI_UNAVAILABLE
 #endif
 
+/* COMPLEX */
+#if !OMPI_SIZEOF_FORTRAN_COMPLEX4
+#undef  OMPI_DATATYPE_MPI_COMPLEX4
+#define OMPI_DATATYPE_MPI_COMPLEX4 OMPI_DATATYPE_MPI_UNAVAILABLE
+#endif
+
+#if !OMPI_SIZEOF_FORTRAN_COMPLEX8
+#undef  OMPI_DATATYPE_MPI_COMPLEX8
+#define OMPI_DATATYPE_MPI_COMPLEX8 OMPI_DATATYPE_MPI_UNAVAILABLE
+#endif
+
+#if !OMPI_SIZEOF_FORTRAN_COMPLEX16
+#undef  OMPI_DATATYPE_MPI_COMPLEX16
+#define OMPI_DATATYPE_MPI_COMPLEX16 OMPI_DATATYPE_MPI_UNAVAILABLE
+#endif
+
+#if !OMPI_SIZEOF_FORTRAN_COMPLEX32
+#undef  OMPI_DATATYPE_MPI_COMPLEX32
+#define OMPI_DATATYPE_MPI_COMPLEX32 OMPI_DATATYPE_MPI_UNAVAILABLE
+#endif
+
+
 /*
  * C++ datatypes, these map to C datatypes.
  */

ompi/mpi/bindings/c_header.py

@@ -279,6 +279,7 @@ def output_constant(const, use_enum: bool, mangle_name: bool):
     output.append("extern int ompi_abi_mpi_win_flavor_dynamic;\n")
     output.append("extern int ompi_abi_mpi_win_model_unified;\n")
     output.append("extern int ompi_abi_mpi_win_model_separate;\n")
+    output.append("extern int ompi_abi_mpi_lastusedcode;\n")
     output.append("\n")
     output.append("int ABI_C_MPI_COMM_NULL_DELETE_FN( MPI_Comm_ABI_INTERNAL comm, int comm_keyval, void* attribute_val_out, void* extra_state );\n")
     output.append("int ABI_C_MPI_COMM_NULL_COPY_FN( MPI_Comm_ABI_INTERNAL  comm, int comm_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, int* flag );\n")

ompi/mpi/bindings/ompi_bindings/c.py

@@ -117,7 +117,6 @@ def dump_header(self):
         self.dump()
 
         self.define_all('MPI_Datatype', consts.PREDEFINED_DATATYPES)
-        self.define_all('MPI_Op', consts.COLLECTIVE_OPERATIONS)
         self.define_all('MPI_Op', consts.RESERVED_OPS)
         self.define_all('MPI_Comm', consts.RESERVED_COMMUNICATORS)
         self.define_all('MPI_Errhandler', consts.RESERVED_ERRHANDLERS)
@@ -428,7 +427,7 @@ def generate_message_convert_fn_intern_to_abi(self):
         self.generic_convert_reverse(ConvertOMPIToStandard.MESSAGE, 'message', 'MPI_Message', consts.RESERVED_MESSAGES)
 
     def generate_op_convert_fn(self):
-        self.generic_convert(ConvertFuncs.OP, 'op', 'MPI_Op', consts.COLLECTIVE_OPERATIONS)
+        self.generic_convert(ConvertFuncs.OP, 'op', 'MPI_Op', consts.RESERVED_OPS)
 
     def generate_op_convert_fn_intern_to_abi(self):
         self.generic_convert_reverse(ConvertOMPIToStandard.OP, 'op', 'MPI_Op', consts.RESERVED_OPS)
@@ -538,6 +537,9 @@ def generate_subarray_order_convert_fn(self):
     def generate_subarray_distrib_types_convert_fn(self):
         self.generic_convert(ConvertFuncs.SUBARRAY_DISTRIB_TYPES, 'dist', 'int', consts.SUBARRAY_DISTRIB_TYPES)
 
+    def generate_subarray_dargs_types_convert_fn(self):
+        self.generic_convert(ConvertFuncs.SUBARRAY_DARGS_TYPES, 'darg', 'int', consts.SUBARRAY_DARGS_TYPES)
+
     def generate_whence_convert_fn(self):
         self.generic_convert(ConvertFuncs.WHENCE, 'whence', 'int', consts.WHENCE_VALUES)
 
@@ -547,9 +549,6 @@ def generate_combiner_convert_fn_intern_to_abi(self):
     def generate_typeclass_convert_fn(self):
         self.generic_convert(ConvertFuncs.TYPECLASS, 'typeclass', 'int', consts.TYPECLASS_VALUES)
 
-    def generate_typeclass_convert_fn(self):
-        self.generic_convert(ConvertFuncs.TYPECLASS, 'typeclass', 'int', consts.TYPECLASS_VALUES)
-
     def generate_win_lock_convert_fn(self):
         self.generic_convert(ConvertFuncs.WIN_LOCK, 'lock_assert', 'int', consts.WIN_LOCK_VALUES)
 
@@ -590,6 +589,34 @@ def generate_mode_bits_convert_fn_intern_to_abi(self):
         self.dump_lines(lines)
         self.dump('}')
 
+    def generate_rma_mode_bits_convert_fn(self):
+        self.dump(f'{consts.INLINE_ATTRS} int {ConvertFuncs.RMA_MODE_BITS}(int mode_bits)')
+        self.dump('{')
+        lines = []
+        lines.append('int ret_value = 0;')
+        for value_name in consts.RMA_MODE_BITS:
+            intern_name = self.mangle_name(value_name)
+            lines.append('if (%s & mode_bits ) {' % (intern_name))
+            lines.append('ret_value |= %s;' % (value_name))
+            lines.append('}')
+        lines.append('return ret_value;')
+        self.dump_lines(lines)
+        self.dump('}')
+
+    def generate_rma_mode_bits_convert_fn_intern_to_abi(self):
+        self.dump(f'{consts.INLINE_ATTRS} int {ConvertOMPIToStandard.RMA_MODE_BITS}(int mode_bits)')
+        self.dump('{')
+        lines = []
+        lines.append('int ret_value = 0;')
+        for value_name in consts.RMA_MODE_BITS:
+            intern_name = self.mangle_name(value_name)
+            lines.append('if (%s & mode_bits ) {' % (value_name))
+            lines.append('ret_value |= %s;' % (intern_name))
+            lines.append('}')
+        lines.append('return ret_value;')
+        self.dump_lines(lines)
+        self.dump('}')
+
 
     def generate_pointer_convert_fn(self, type_, fn_name, constants):
         abi_type = self.mangle_name(type_)
@@ -623,15 +650,11 @@ def generate_status_convert_fn(self):
         self.dump(f'{consts.INLINE_ATTRS} void {ConvertFuncs.STATUS}({type_} *out, {abi_type} *inp)')
         self.dump('{')
         self.dump('    void *ptr = &out->_ucount;')
-        self.dump('    if(inp->MPI_SOURCE == MPI_ANY_SOURCE_ABI_INTERNAL) {')
-        self.dump('        out->MPI_SOURCE = MPI_ANY_SOURCE;')
-        self.dump('    } else {')
-        self.dump('        out->MPI_SOURCE = inp->MPI_SOURCE;')
-        self.dump('    }')
+        self.dump(f'    out->MPI_SOURCE = {ConvertFuncs.SOURCE}(inp->MPI_SOURCE);')
         self.dump(f'    out->MPI_TAG = {ConvertFuncs.TAG}(inp->MPI_TAG);')
         self.dump('    out->_cancelled = inp->MPI_internal[0];')
-        self.dump('    memcpy(ptr, &inp->MPI_internal[1],sizeof(out->_ucount));')
-        self.dump(f'   out->MPI_ERROR = {ConvertFuncs.ERROR_CLASS}(inp->MPI_ERROR);')
+        self.dump('    memcpy(ptr, &inp->MPI_internal[1], sizeof(out->_ucount));')
+        self.dump(f'    out->MPI_ERROR = {ConvertFuncs.ERROR_CLASS}(inp->MPI_ERROR);')
         # Ignoring the private fields for now
         self.dump('}')
 
@@ -643,8 +666,8 @@ def generate_status_convert_fn_intern_to_abi(self):
         self.dump('    void *ptr = &out->MPI_internal[1];')
         self.dump(f'    out->MPI_SOURCE = {ConvertOMPIToStandard.SOURCE}(inp->MPI_SOURCE);')
         self.dump(f'    out->MPI_TAG = {ConvertOMPIToStandard.TAG}(inp->MPI_TAG);')
-        self.dump('    out->MPI_internal[0] =inp->_cancelled;')
-        self.dump('    memcpy(ptr, &inp->_ucount,sizeof(inp->_ucount));')
+        self.dump('    out->MPI_internal[0] = inp->_cancelled;')
+        self.dump('    memcpy(ptr, &inp->_ucount, sizeof(inp->_ucount));')
         self.dump(f'    out->MPI_ERROR = {ConvertOMPIToStandard.ERROR_CLASS}(inp->MPI_ERROR);')
         # Ignoring the private fields for now
         self.dump('}')
@@ -675,6 +698,21 @@ def dump_code(self):
         self.dump(' */')
         self.dump('#define OMPI_ABI_HANDLE_BASE_OFFSET 16385')
         self.dump('\n')
+        self.dump('/*')
+        self.dump(' * helper functions for abi generated routines ')
+        self.dump(' */')
+        self.dump(f'{consts.INLINE_ATTRS} void *ompi_abi_malloc(MPI_Count count, size_t elsize)')
+        self.dump('{')
+        lines = []
+        lines.append('void *aptr = NULL;')
+        lines.append('if (count > 0) {')
+        lines.append('aptr = (void *)malloc(count * elsize);')
+        lines.append('assert(NULL != aptr);')
+        lines.append('}')
+        lines.append('return aptr;')
+        lines.append('}')
+        lines.append('\n')
+        self.dump_lines(lines)
 
         # Now generate the conversion code - there's a reason for the order here
         # some converters depend on others being declared earlier in the include
@@ -733,6 +771,8 @@ def dump_code(self):
         self.generate_pvar_class_convert_fn_intern_to_abi()
         self.generate_mode_bits_convert_fn()
         self.generate_mode_bits_convert_fn_intern_to_abi()
+        self.generate_rma_mode_bits_convert_fn()
+        self.generate_rma_mode_bits_convert_fn_intern_to_abi()
         self.generate_buffer_convert_fn()
         self.generate_buffer_convert_fn_intern_to_abi()
 
@@ -749,10 +789,12 @@ def dump_code(self):
         self.generate_weight_convert_fn()
         self.generate_subarray_order_convert_fn()
         self.generate_subarray_distrib_types_convert_fn()
+        self.generate_subarray_dargs_types_convert_fn()
         self.generate_root_convert_fn()
         self.generate_t_cb_safety_convert_fn()
         self.generate_win_lock_convert_fn()
         self.generate_whence_convert_fn()
+        self.generate_typeclass_convert_fn()
 
         #
         # the following only need intern to abi converters