SQUASHME: OMNIBUS COMMIT 3

add replacements to code bodies for various string lengths

We now scan the generated internal 'c' body of each
function for replaceable variants of

MPI_MAX_DATAREP_STRING
MPI_MAX_ERROR_STRING
MPI_MAX_INFO_KEY
MPI_MAX_INFO_VAL
MPI_MAX_LIBRARY_VERSION_STRING
MPI_MAX_OBJECT_NAME
MPI_MAX_PORT_NAME
MPI_MAX_PROCESSOR_NAME
MPI_MAX_STRINGTAG_LEN
MPI_MAX_PSET_NAME_LEN

This way the code body sees the same constant values as the
app sees using either the OMPI or ABI variants of the mpi.h

add support for distrib array and order

for subarray type datatype constructors

add support for mode bits - in only

add support for amode out

add support for whence

used by some MPI I/O functions

add support for some win attributes

handle special case of MPI_DISPLACEMENT_CURRENT

add support for combiner, typeclass, win lock assert

types

c_header: comment out deprecated functions

The ABI doesn't support any of the functions deprecated in MPI 3.1
or earlier.  See section 20.2.1 of the MPI 5.0 standard.

fix problem with special attrs for windows

fix for win_shared_query

fixes to rget/rget_accumulate

fix problem with code gen for win create keyval

fix rank problem in rput/raccumulate

add MPI_GROUP_EMPTY to predefined group handles

handle user error classes and codes

temporary WAR for non-blocking alltoallw

variants.

We'll need to append the temporary arrays holding
translated datatype handles to the nbc request for
cleanup after the non-blocking op is completed or
the persistent request has been freed.

add support for comm topos

support INOUT attribute for all handles

thanks to dalcinl for help here

fix problem with attribute callback handling

need to convert the ompi internal keyval to abi one
before invoking user supplied callbacks for win, type, comm

catch use of special buffer consts

like MPI_BUFFER_AUTOMATIC

remove some debug statements

swat nit

patch get_address

add new type to handle out void stars

from buffer detach operations.

fixes for datatypes for neighbor collectives

add inouts for op, errhandler, info

cleanup datatype tmps for ialltoallw and friends

leverage nbc infrastructure

a logical16 fix

Thanks to dalcinl for finding.

abi_get_version/get_info add to ompi abi lib

and correction major/minor versoin returned from the ABI
build.

toint fixes

thanks to dalcinl !

fix issue with ASYNC data arrays cleanup

various fixes from dalcinl

Signed-off-by: Howard Pritchard <howardp@lanl.gov>

Author: hppritcha

.gitignore

@@ -538,6 +538,7 @@ ompi/mpi/c/*_generated*.c
 ompi/mpi/c/standard_*.c
 ompi/mpi/c/abi.h
 ompi/mpi/c/abi_get_info.c
+ompi/mpi/c/abi_converters.h
 ompi/mpi/c/standard_abi
 ompi/mpi/tool/*_generated*.c
 

ompi/include/mpi.h.in

@@ -1453,9 +1453,8 @@ OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_ub;
 /*
  * MPI API
  */
-OMPI_DECLSPEC  int MPI_Abi_supported(int *flag);
-OMPI_DECLSPEC  int MPI_Abi_version(int *abi_major, int *abi_minor);
-OMPI_DECLSPEC  int MPI_Abi_details(int *buflen, char *details, MPI_Info *info);
+OMPI_DECLSPEC  int MPI_Abi_get_version(int *abi_major, int *abi_minor);
+OMPI_DECLSPEC  int MPI_Abi_get_info(MPI_Info *info);
 OMPI_DECLSPEC  int MPI_Abi_get_fortran_info(MPI_Info *info);
 OMPI_DECLSPEC  int MPI_Abi_set_fortran_info(MPI_Info info);
 OMPI_DECLSPEC  int MPI_Abi_get_fortran_booleans(int logical_size, void *logical_true, void *logical_false, int *is_set);
@@ -2656,9 +2655,8 @@ OMPI_DECLSPEC  double MPI_Wtime(void);
   /*
    * Profiling MPI API
    */
-OMPI_DECLSPEC  int PMPI_Abi_supported(int *flag);
-OMPI_DECLSPEC  int PMPI_Abi_version(int *abi_major, int *abi_minor);
-OMPI_DECLSPEC  int PMPI_Abi_details(int *buflen, char *details, MPI_Info *info);
+OMPI_DECLSPEC  int PMPI_Abi_get_version(int *abi_major, int *abi_minor);
+OMPI_DECLSPEC  int PMPI_Abi_get_info(MPI_Info *info);
 OMPI_DECLSPEC  int PMPI_Abi_get_fortran_info(MPI_Info *info);
 OMPI_DECLSPEC  int PMPI_Abi_set_fortran_info(MPI_Info info);
 OMPI_DECLSPEC  int PMPI_Abi_get_fortran_booleans(int logical_size, void *logical_true, void *logical_false, int *is_set);

ompi/mpi/bindings/c_header.py

@@ -57,6 +57,24 @@
     "MPI_Delete_function",
 ]
 
+DEPRECATED_FUNCTIONS = [
+    "MPI_Keyval_create",
+    "MPI_Keyval_free",
+    "MPI_Attr_put",
+    "MPI_Attr_get",
+    "MPI_Attr_delete",
+    "MPI_Address",
+    "MPI_Errhandler_create",
+    "MPI_Errhandler_get",
+    "MPI_Errhandler_set",
+    "MPI_Type_extent",
+    "MPI_Type_hindexed",
+    "MPI_Type_hvector",
+    "MPI_Type_lb",
+    "MPI_Type_struct",
+    "MPI_Type_ub",
+]
+
 ENUM_CATEGORIES = [
     "ERROR_CLASSES",
     "MODE_CONSTANTS",
@@ -255,6 +273,12 @@ def output_constant(const, use_enum: bool, mangle_name: bool):
     output.append(" */\n")
     output.append("extern int ompi_abi_mpi_proc_null_val;\n")
     output.append("extern int ompi_abi_mpi_any_source_val;\n")
+    output.append("extern int ompi_abi_mpi_win_flavor_create;\n")
+    output.append("extern int ompi_abi_mpi_win_flavor_allocate;\n")
+    output.append("extern int ompi_abi_mpi_win_flavor_shared;\n")
+    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("\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")
@@ -296,9 +320,17 @@ def output_constant(const, use_enum: bool, mangle_name: bool):
             # like "MPI_Group_difference"
             datatype_pattern = r"([\( ]?)(" + datatype + r")([; \*\)]{1})"
             line = re.sub(datatype_pattern, f"\\g<1>\\g<2>{ABI_INTERNAL}\\g<3>", line)
+    # TODO: need to enhance pympistandard to be able to prune out deprecated functions
+    # This stands in as a workaround
+    comment_out = any(i in line for i in DEPRECATED_FUNCTIONS)
+
+    # function is not in the ABI standard (things in MPI 5.1 chapter 19 sections 19.3.4 and 19.3.5
     # TODO: need to enhance pympistandard to have field in json to indicate a 
     # function is not in the ABI standard (things in MPI 5.1 chapter 19 sections 19.3.4 and 19.3.5
     if "MPI_Fint" in line or "MPI_F08_status" in line:
+        comment_out = True
+
+    if comment_out == True:
         # Comment out a line if it has references to MPI_Fint or MPI_F08_status, since
         # functions with these argument types are not in the ABI
         line = line[:-1]

ompi/mpi/bindings/ompi_bindings/c.py

@@ -34,7 +34,7 @@
 from ompi_bindings.c_type import Type
 from ompi_bindings.parser import SourceTemplate
 
-c_intrinsic_types = ['char', 'int', 'long int']
+c_intrinsic_types = ['char', 'int', 'long int', 'void']
 #OMPI_ABI_HANDLE_BASE_OFFSET = '16385'
 
 class ABIHeaderBuilder:
@@ -226,7 +226,7 @@ def generate_error_convert_fn(self):
             lines.append(f'case {self.mangle_name(error)}:')
             lines.append(f'return {error};')
         lines.append('default:')
-        lines.append('return error_class;')
+        lines.append('return (error_class - %s);' % ('OMPI_ABI_HANDLE_BASE_OFFSET'))
         lines.append('}')
         self.dump_lines(lines)
         self.dump('}')
@@ -240,7 +240,7 @@ def generate_error_convert_fn_intern_to_abi(self):
             lines.append(f'case {error}:')
             lines.append(f'return {self.mangle_name(error)};')
         lines.append('default:')
-        lines.append('return error_class;')
+        lines.append('return (error_class + %s);' % ('OMPI_ABI_HANDLE_BASE_OFFSET'))
         lines.append('}')
         self.dump_lines(lines)
         self.dump('}')
@@ -338,10 +338,17 @@ def generic_convert(self, fn_name, param_name, type_, value_names, offset=None):
         self.dump('}')
 
     def generic_convert_reverse(self, fn_name, param_name, type_, value_names, offset=None):
-        if type_ not in c_intrinsic_types:
-            intern_type = self.mangle_name(type_)
+        is_ptr_arg = False
+        tmp_type = type_
+        if (tmp_type[-1] == '*'):
+            is_ptr_arg = True
+            tmp_type = tmp_type[:-1].strip()
+        if tmp_type not in c_intrinsic_types:
+            intern_type = self.mangle_name(tmp_type)
         else:
-            intern_type = type_
+            intern_type = tmp_type
+        if (is_ptr_arg == True):
+            intern_type = intern_type + ' *'
         self.dump(f'{consts.INLINE_ATTRS} {intern_type} {fn_name}({type_} {param_name})')
         self.dump('{')
         lines = []
@@ -525,6 +532,65 @@ def generate_comm_split_type_convert_fn(self):
     def generate_weight_convert_fn(self):
         self.generic_convert(ConvertFuncs.WEIGHTS, 'weights', 'int *', consts.RESERVED_WEIGHTS)
 
+    def generate_subarray_order_convert_fn(self):
+        self.generic_convert(ConvertFuncs.SUBARRAY_ORDER, 'order', 'int', consts.SUBARRAY_ORDER_TYPES)
+
+    def generate_subarray_distrib_types_convert_fn(self):
+        self.generic_convert(ConvertFuncs.SUBARRAY_DISTRIB_TYPES, 'dist', 'int', consts.SUBARRAY_DISTRIB_TYPES)
+
+    def generate_whence_convert_fn(self):
+        self.generic_convert(ConvertFuncs.WHENCE, 'whence', 'int', consts.WHENCE_VALUES)
+
+    def generate_combiner_convert_fn_intern_to_abi(self):
+        self.generic_convert_reverse(ConvertOMPIToStandard.COMBINER, 'combiner', 'int', consts.COMBINER_VALUES)
+
+    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)
+
+    def generate_topo_convert_fn_intern_to_abi(self):
+        self.generic_convert_reverse(ConvertOMPIToStandard.TOPO, 'status', 'int', consts.TOPO_VALUES)
+
+    def generate_buffer_convert_fn(self):
+        self.generic_convert(ConvertFuncs.BUFFER, 'buffer', 'void *', consts.BUFFER_VALUES)
+
+    def generate_buffer_convert_fn_intern_to_abi(self):
+        self.generic_convert_reverse(ConvertOMPIToStandard.BUFFER, 'buffer', 'void *', consts.BUFFER_VALUES)
+
+    def generate_mode_bits_convert_fn(self):
+        self.dump(f'{consts.INLINE_ATTRS} int {ConvertFuncs.MODE_BITS}(int mode_bits)')
+        self.dump('{')
+        lines = []
+        lines.append('int ret_value = 0;')
+        for value_name in consts.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_mode_bits_convert_fn_intern_to_abi(self):
+        self.dump(f'{consts.INLINE_ATTRS} int {ConvertOMPIToStandard.MODE_BITS}(int mode_bits)')
+        self.dump('{')
+        lines = []
+        lines.append('int ret_value = 0;')
+        for value_name in consts.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_)
         self.dump(f'{consts.INLINE_ATTRS} void {fn_name}({abi_type} *ptr)')
@@ -665,6 +731,10 @@ def dump_code(self):
         self.generate_t_source_order_convert_fn_intern_to_abi()
         self.generate_pvar_class_convert_fn()
         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_buffer_convert_fn()
+        self.generate_buffer_convert_fn_intern_to_abi()
 
         #
         # the following only need abi to intern converters
@@ -677,13 +747,19 @@ def dump_code(self):
         self.generate_win_delete_attr_convert_fn()
         self.generate_comm_split_type_convert_fn()
         self.generate_weight_convert_fn()
+        self.generate_subarray_order_convert_fn()
+        self.generate_subarray_distrib_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()
 
         #
         # the following only need intern to abi converters
         #
         self.generate_comm_cmp_convert_fn_intern_to_abi()
-        self.generate_root_convert_fn()
-        self.generate_t_cb_safety_convert_fn()
+        self.generate_combiner_convert_fn_intern_to_abi()
+        self.generate_topo_convert_fn_intern_to_abi()
 
         self.dump("""
 #if defined(c_plusplus) || defined(__cplusplus)
@@ -718,6 +794,16 @@ def print_cdefs_for_abi(out, abi_type='ompi'):
         out.dump('#undef OMPI_ABI_SRC')
         out.dump('#define OMPI_ABI_SRC 1')
 
+def generate_replacements(mangle_names=False):
+    replacements = {}
+    for key in consts.MAX_STRING_LEN_CONSTANTS:
+        if mangle_names == True:
+            val = util.abi_internal_name(key)
+        else:
+            val = key
+        replacements[key] = val
+    return replacements
+
 def ompi_abi(base_name, template, out, suppress_bc=False, suppress_nbc=False):
     """Generate the OMPI ABI functions."""
     template.print_header(out)
@@ -726,7 +812,8 @@ def ompi_abi(base_name, template, out, suppress_bc=False, suppress_nbc=False):
         print_cdefs_for_bigcount(out)
         print_cdefs_for_abi(out)
         out.dump(template.prototype.signature(base_name, abi_type='ompi'))
-        template.print_body(func_name=base_name, out=out)
+        template.print_body(func_name=base_name, out=out,
+                            replacements=generate_replacements(mangle_names=False))
     # Check if we need to generate the bigcount interface
     if util.prototype_has_bigcount(template.prototype) and suppress_bc == False:
         # there are some special cases where we need to explicitly define the bigcount functions in the template file
@@ -738,8 +825,8 @@ def ompi_abi(base_name, template, out, suppress_bc=False, suppress_nbc=False):
         print_cdefs_for_bigcount(out, enable_count=True)
         print_cdefs_for_abi(out)
         out.dump(template.prototype.signature(base_name_c, abi_type='ompi', enable_count=True))
-        template.print_body(func_name=base_name_c, out=out)
-
+        template.print_body(func_name=base_name_c, out=out,
+                            replacements=generate_replacements(mangle_names=False))
 
 ABI_INTERNAL_HEADER = 'ompi/mpi/c/abi.h'
 ABI_INTERNAL_CONVERTOR = 'ompi/mpi/c/abi_converters.h'
@@ -771,15 +858,15 @@ def standard_abi(base_name, template, out, suppress_bc=False, suppress_nbc=False
         internal_sig = template.prototype.signature(internal_name, abi_type='ompi',
                                                     enable_count=False)
         out.dump(consts.INLINE_ATTRS, internal_sig)
-        template.print_body(func_name=base_name, out=out)
+        template.print_body(func_name=base_name, out=out, replacements=generate_replacements(mangle_names=True))
     if util.prototype_has_bigcount(template.prototype) and suppress_bc == False:
         internal_name = f'ompi_abi_{template.prototype.name}_c'
         print_cdefs_for_bigcount(out, enable_count=True)
         print_cdefs_for_abi(out, abi_type='standard')
         internal_sig = template.prototype.signature(internal_name, abi_type='ompi',
                                                     enable_count=True)
         out.dump(consts.INLINE_ATTRS, internal_sig)
-        template.print_body(func_name=base_name, out=out)
+        template.print_body(func_name=base_name, out=out, replacements=generate_replacements(mangle_names=True))
 
     def generate_function(prototype, fn_name, internal_fn, out, enable_count=False):
         """Generate a function for the standard ABI."""
@@ -794,6 +881,10 @@ def generate_function(prototype, fn_name, internal_fn, out, enable_count=False):
         return_type = prototype.return_type.construct(abi_type='standard')
         lines.append(f'{return_type.tmp_type_text()} ret_value;')
         for param in params:
+            if param.need_async_cleanup == True:
+                lines.append('int idx  = 0;')
+                break
+        for param in params:
 #           print("param = " + str(param) + " " + str(param.argument))
             if param.init_code:
                 lines.extend(param.init_code)