some fixes and start of a wrapper method

for comm/type/win attributes.

Not clear if this is the way to handle attr copy/del call
backs compiled againt the mpi.h ABI header file.

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

Author: hppritcha

ompi/attribute/attribute.h

@@ -50,6 +50,7 @@
 #define OMPI_KEYVAL_PREDEFINED     0x0001
 #define OMPI_KEYVAL_F77            0x0002
 #define OMPI_KEYVAL_F77_INT        0x0004
+#define OMPI_KEYVAL_ABI            0x0008
 
 
 BEGIN_C_DECLS
@@ -136,7 +137,7 @@ struct ompi_attribute_keyval_t {
                                        copy/delete attribute functions
                                        properly and error checking */
     int attr_flag; /**< flag field: contains "OMPI_KEYVAL_PREDEFINED",
-                      "OMPI_KEYVAL_F77"  */
+                      "OMPI_KEYVAL_F77", "OMPI_KEYVAL_ABI", etc.  */
     ompi_attribute_fn_ptr_union_t copy_attr_fn; /**< Copy function for the
                                              attribute */
     ompi_attribute_fn_ptr_union_t delete_attr_fn; /**< Delete function for the

ompi/mpi/bindings/ompi_bindings/c.py

@@ -322,13 +322,35 @@ def dump_header(self):
         # user functions
         self.dump('typedef int (MPI_Copy_function)(MPI_Comm_ABI_INTERNAL, int, void *, void *, void *, int *);')
         self.dump('typedef int (MPI_Delete_function)(MPI_Comm_ABI_INTERNAL, int, void *, void *);')
+#
+#       generate prototypes for user call back functions
+#
+        for handle in consts.C_ATTRIBUTE_OBJS:
+            prefix, suffix = handle.split('_')
+            copy_callback_func_name = f'{handle}_copy_attr_function'
+            copy_callback_func_name = f'{self.mangle_name(copy_callback_func_name)}'
+            delete_callback_func_name = f'{handle}_delete_attr_function'
+            delete_callback_func_name = f'{self.mangle_name(delete_callback_func_name)}'
+            #
+            # stupid MPI standard naming consistency
+            #
+            if handle == 'MPI_Type':
+                obj_arg_type = f'{self.mangle_name("MPI_Datatype")}'
+            else:
+                obj_arg_type = f'{self.mangle_name(handle)}'
+            obj_arg_name = f'old{suffix}'.lower()
+            obj_arg = f'{obj_arg_type} {obj_arg_name}'
+            keyval_arg = f'int {suffix}_keyval'.lower()
+            self.dump(f'typedef int ({copy_callback_func_name})({obj_arg}, {keyval_arg}, void *, void *, void *,int *);')
+            self.dump(f'typedef int ({delete_callback_func_name})({obj_arg}, {keyval_arg}, void *, void *);')
+
         # Function signatures
         for sig in self.signatures:
             self.dump(f'{sig};')
-#           print("Working on signature " + str(sig))
         self.dump('int MPI_Abi_details(int *buflen, char *details, MPI_Info *info);')
         self.dump('int MPI_Abi_supported(int *flag);')
         self.dump('int MPI_Abi_version(int *abi_major, int *abi_minor);')
+
         if not self.external:
             # Now generate the conversion code
             self.generate_error_convert_fn()
@@ -383,18 +405,28 @@ def print_cdefs_for_bigcount(out, enable_count=False):
         out.dump('#undef OMPI_BIGCOUNT_SRC')
         out.dump('#define OMPI_BIGCOUNT_SRC 0')
 
+def print_cdefs_for_abi(out, abi_type='ompi'):
+    if abi_type == 'ompi':
+        out.dump('#undef OMPI_ABI_SRC')
+        out.dump('#define OMPI_ABI_SRC 0')
+    else:
+        out.dump('#undef OMPI_ABI_SRC')
+        out.dump('#define OMPI_ABI_SRC 1')
+
 def ompi_abi(base_name, template, out):
     """Generate the OMPI ABI functions."""
     template.print_header(out)
     print_profiling_header(base_name, out)
     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)
     # Check if we need to generate the bigcount interface
     if util.prototype_has_bigcount(template.prototype):
         base_name_c = f'{base_name}_c'
         print_profiling_header(base_name_c, out)
         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)
 
@@ -406,17 +438,26 @@ def standard_abi(base_name, template, out):
     """Generate the standard ABI functions."""
     template.print_header(out)
     out.dump(f'#include "{ABI_INTERNAL_HEADER}"')
+    print_cdefs_for_abi(out,abi_type='standard')
+
+    # If any parameters are pointers to user callback functions, generate code
+    # for callback wrappers
+#   if util.prototype_needs_callback_wrappers(template.prototype):
+#       for param in prototype.params:
+#           if param.callback_wrapper_code:
 
     # Static internal function (add a random component to avoid conflicts)
     internal_name = f'ompi_abi_{template.prototype.name}'
     print_cdefs_for_bigcount(out)
+    print_cdefs_for_abi(out, abi_type='standard')
     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)
     if util.prototype_has_bigcount(template.prototype):
         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)

ompi/mpi/bindings/ompi_bindings/c_type.py

@@ -1152,7 +1152,23 @@ class TypeCommCopyAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Comm_copy_attr_function *'
+        type_name = self.mangle_name('MPI_Comm_copy_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Comm_copy_attr_function *) {self.name}'
+
+#   @property
+#   def init_code(self):
+#       code = []
+#       code = ['ompi_abi_wrapper_helper_t *helper = NULL;']
+#       code.append('helper = ( ompi_abi_wrapper_helper_t *)malloc(sizeof(ompi_abi_wrapper_helper_t));')
+#       code.append('if (NULL == helper)  return MPI_ERR_NO_MEM;')
+#       code.append('helper->user_extra_state = extra_state;')
+#       code.append('helper->user_copy_fn = comm_copy_attr_fn;')
+#       code.append('helper->user_delete_fn = comm_delete_attr_fn;')
+#       return code
 
 @Type.add_type('COMM_DELETE_ATTR_FUNCTION', abi_type=['ompi'])
 class TypeCommDeleteAttrFunction(Type):
@@ -1167,7 +1183,12 @@ class TypeCommDeleteAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Comm_delete_attr_function *'
+        type_name = self.mangle_name('MPI_Comm_delete_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Comm_delete_attr_function *) {self.name}'
 
 @Type.add_type('GREQUEST_QUERY_FUNCTION', abi_type=['ompi'])
 class TypeGrequestQueryFunction(Type):
@@ -1279,7 +1300,12 @@ class TypeTypeCopyAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Type_copy_attr_function *'
+        type_name = self.mangle_name('MPI_Type_copy_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Type_copy_attr_function *) {self.name}'
 
 @Type.add_type('TYPE_DELETE_ATTR_FUNCTION', abi_type=['ompi'])
 class TypeTypeDeleteAttrFunction(Type):
@@ -1294,9 +1320,15 @@ class TypeTypeDeleteAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Type_delete_attr_function *'
+        type_name = self.mangle_name('MPI_Type_delete_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Type_delete_attr_function *) {self.name}'
 
 @Type.add_type('WIN_ERRHANDLER_FUNCTION', abi_type=['ompi'])
+
 class TypeWinErrhandlerFunction(Type):
 
     def type_text(self, enable_count=False):
@@ -1324,7 +1356,12 @@ class TypeWinCopyAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Win_copy_attr_function *'
+        type_name = self.mangle_name('MPI_Win_copy_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Win_copy_attr_function *) {self.name}'
 
 @Type.add_type('WIN_DELETE_ATTR_FUNCTION', abi_type=['ompi'])
 class TypeWinDeleteAttrFunction(Type):
@@ -1339,7 +1376,12 @@ class TypeWinDeleteAttrFunctionStandard(Type):
 #    pass
 
     def type_text(self, enable_count=False):
-        return 'MPI_Win_delete_attr_function *'
+        type_name = self.mangle_name('MPI_Win_delete_attr_function')
+        return f'{type_name} *'
+
+    @property
+    def argument(self):
+        return f'(MPI_Win_delete_attr_function *) {self.name}'
 
 @Type.add_type('ERRHANDLER', abi_type=['ompi'])
 class TypeErrhandler(Type):
@@ -1448,23 +1490,23 @@ def type_text(self, enable_count=False):
 
 
 @Type.add_type('SESSION_INOUT', abi_type=['standard'])
-class TypeSessionOutStandard(StandardABIType):
+class TypeSessionInOutStandard(StandardABIType):
 
-#   @property
-#   def init_code(self):
-#       return [f'MPI_Session {self.tmpname} = {ConvertFuncs.SESSION}(*{self.name});']
+    @property
+    def init_code(self):
+        return [f'MPI_Session {self.tmpname} = {ConvertFuncs.SESSION}(*{self.name});']
 
     @property
     def final_code(self):
-        return [f'*{self.name} = {ConvertOMPIToStandard.SESSION}((MPI_Session) *{self.name});']
+        return [f'*{self.name} = {ConvertOMPIToStandard.SESSION}({self.tmpname});']
 
     def type_text(self, enable_count=False):
         type_name = self.mangle_name('MPI_Session')
         return f'{type_name} *'
 
     @property
     def argument(self):
-        return f'(MPI_Session *) {self.name}'
+        return f'&{self.tmpname}'
 
 
 @Type.add_type('SESSION_OUT', abi_type=['standard'])

ompi/mpi/bindings/ompi_bindings/consts.py

@@ -250,6 +250,15 @@
     'MPI_Win',
 ]
 
+#
+# C objects that can have attributes cached on them
+#
+C_ATTRIBUTE_OBJS = [
+    'MPI_Comm',
+    'MPI_Type',
+    'MPI_Win',
+]
+
 class ConvertFuncs:
     """Names of conversion functions (between standard ABI and OMPI ABI)."""
 
@@ -262,7 +271,7 @@ class ConvertFuncs:
     STATUS = 'ompi_convert_abi_status_intern_status'
     MESSAGE = 'ompi_convert_abi_message_intern_message'
     OP = 'ompi_convert_abi_op_intern_op'
-    SESSION = 'ompi_convert_abi_session_intern_win'
+    SESSION = 'ompi_convert_abi_session_intern_session'
     WIN = 'ompi_convert_abi_win_intern_win'
     INFO = 'ompi_convert_abi_info_intern_info'
     FILE = 'ompi_convert_abi_file_intern_file'

ompi/mpi/bindings/ompi_bindings/util.py

@@ -147,7 +147,6 @@ def abi_internal_name(extname):
     'DATAREP_CONVERSION_FUNCTION',
 ]
 
-
 def prototype_has_bigcount(prototype):
     """Should this prototype have a bigcount version?"""
     return any(param.type_name in BIGCOUNT_TYPE_NAMES for param in prototype.params)
@@ -165,3 +164,17 @@ def prototype_has_buffers(prototype):
         return True
     else:
         return False
+
+USER_CALLBACK_NAMES = [
+    'COMM_COPY_ATTR_FUNCTION',
+    'COMM_DELETE_ATTR_FUNCTION',
+    'TYPE_COPY_ATTR_FUNCTION',
+    'TYPE_DELETE_ATTR_FUNCTION',
+    'WIN_COPY_ATTR_FUNCTION',
+    'WIN_DELETE_ATTR_FUNCTION',
+]   
+
+def prototype_needs_callback_wrappers(prototype):
+    """Should this prototype need a callback wrappers"""
+    return any(param.type_name in USER_CALLBACK_NAMES for param in prototype.params)
+

ompi/mpi/c/comm_create_keyval.c.in

@@ -36,6 +36,7 @@ PROTOTYPE ERROR_CLASS comm_create_keyval(COMM_COPY_ATTR_FUNCTION comm_copy_attr_
                                          INT_OUT comm_keyval, BUFFER_OUT extra_state)
 {
     int ret;
+    int flags = 0;
     ompi_attribute_fn_ptr_union_t copy_fn;
     ompi_attribute_fn_ptr_union_t del_fn;
 
@@ -48,11 +49,14 @@ PROTOTYPE ERROR_CLASS comm_create_keyval(COMM_COPY_ATTR_FUNCTION comm_copy_attr_
         }
     }
 
-    copy_fn.attr_communicator_copy_fn = comm_copy_attr_fn;
-    del_fn.attr_communicator_delete_fn = comm_delete_attr_fn;
+    copy_fn.attr_communicator_copy_fn = (MPI_Comm_copy_attr_function *)comm_copy_attr_fn;
+    del_fn.attr_communicator_delete_fn = (MPI_Comm_delete_attr_function *)comm_delete_attr_fn;
 
-    ret = ompi_attr_create_keyval(COMM_ATTR, copy_fn,
-                                  del_fn, comm_keyval, extra_state, 0, NULL);
+#if OMPI_ABI_SRC
+    flags |= OMPI_KEYVAL_ABI;
+#endif
+    ret = ompi_attr_create_keyval(COMM_ATTR, copy_fn, del_fn,
+                                  comm_keyval, extra_state, flags, NULL);
 
     OMPI_ERRHANDLER_NOHANDLE_RETURN(ret, MPI_ERR_OTHER, FUNC_NAME);
 }

ompi/mpi/c/type_create_keyval.c.in

@@ -36,7 +36,7 @@ PROTOTYPE ERROR_CLASS type_create_keyval(TYPE_COPY_ATTR_FUNCTION type_copy_attr_
                                          INT_OUT type_keyval,
                                          BUFFER_OUT extra_state)
 {
-    int ret;
+    int ret, flags = 0;
     ompi_attribute_fn_ptr_union_t copy_fn;
     ompi_attribute_fn_ptr_union_t del_fn;
 
@@ -53,8 +53,12 @@ PROTOTYPE ERROR_CLASS type_create_keyval(TYPE_COPY_ATTR_FUNCTION type_copy_attr_
     copy_fn.attr_datatype_copy_fn = type_copy_attr_fn;
     del_fn.attr_datatype_delete_fn = type_delete_attr_fn;
 
+#if OMPI_ABI_SRC
+    flags |= OMPI_KEYVAL_ABI;
+#endif
+
     ret = ompi_attr_create_keyval(TYPE_ATTR, copy_fn, del_fn,
-                                  type_keyval, extra_state, 0, NULL);
+                                  type_keyval, extra_state, flags, NULL);
     OMPI_ERRHANDLER_NOHANDLE_RETURN(ret, ret, FUNC_NAME);
 }
 

ompi/mpi/c/win_create_keyval.c.in

@@ -35,7 +35,7 @@ PROTOTYPE ERROR_CLASS win_create_keyval(WIN_COPY_ATTR_FUNCTION win_copy_attr_fn,
                                         WIN_DELETE_ATTR_FUNCTION win_delete_attr_fn,
                                         INT_OUT win_keyval, BUFFER_OUT extra_state)
 {
-    int ret;
+    int ret, flags = 0;
     ompi_attribute_fn_ptr_union_t copy_fn;
     ompi_attribute_fn_ptr_union_t del_fn;
 
@@ -48,10 +48,14 @@ PROTOTYPE ERROR_CLASS win_create_keyval(WIN_COPY_ATTR_FUNCTION win_copy_attr_fn,
         }
     }
 
-    copy_fn.attr_win_copy_fn = win_copy_attr_fn;
-    del_fn.attr_win_delete_fn = win_delete_attr_fn;
+    copy_fn.attr_win_copy_fn = (MPI_Win_copy_attr_function *)win_copy_attr_fn;
+    del_fn.attr_win_delete_fn = (MPI_Win_delete_attr_function *)win_delete_attr_fn;
+
+#if OMPI_ABI_SRC
+    flags |= OMPI_KEYVAL_ABI;
+#endif
 
     ret = ompi_attr_create_keyval(WIN_ATTR, copy_fn, del_fn,
-                                  win_keyval, extra_state, 0, NULL);
+                                  win_keyval, extra_state, flags, NULL);
     OMPI_ERRHANDLER_NOHANDLE_RETURN(ret, MPI_ERR_OTHER, FUNC_NAME);
 }