SQUASH_ME: OMNIBUS commit 7

to heed the --enable-abi-standard config option

makefile fixes

checkpoint

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.

attributes: add wrapper infrastructure

This approach works for attributes but other approaches will
be needed for error handlers and datatype conversion related
functions.

abi: move converter functions to a persistent file

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

Author: hppritcha

.gitignore

@@ -535,7 +535,6 @@ docs/man
 
 # Generated C Bindings
 ompi/mpi/c/*_generated*.c
-ompi/mpi/c/ompi_*.c
 ompi/mpi/c/standard_*.c
 ompi/mpi/c/abi.h
 ompi/mpi/c/standard_abi

ompi/attribute/attribute.c

@@ -322,6 +322,7 @@ do { \
     /* C style */ \
     else { \
         void *attr_val = translate_to_c(attribute); \
+        /* TODO: NEED SUPPORT FOR ABI */ \
         err = (*((keyval_obj->delete_attr_fn).attr_##type##_delete_fn)) \
             ((ompi_##type##_t *)object,                                 \
              key, attr_val,                                             \
@@ -381,6 +382,7 @@ do { \
     else { \
         void *in, *out; \
         in = translate_to_c(in_attr); \
+        /* TODO: NEED SUPPORT FOR ABI */ \
         if ((err = (*((keyval_obj->copy_attr_fn).attr_##type##_copy_fn)) \
               ((ompi_##type##_t *)old_object, key, keyval_obj->extra_state.c_ptr, \
                in, &out, &flag)) == MPI_SUCCESS) { \

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

@@ -218,8 +218,11 @@ def generate_status_convert_fn(self):
         abi_type = self.mangle_name(type_)
         self.dump(f'{consts.INLINE_ATTRS} void {ConvertFuncs.STATUS}({type_} *out, {abi_type} *inp)')
         self.dump('{')
+        self.dump('    void *ptr = &out->_ucount;')
         self.dump('    out->MPI_SOURCE = inp->MPI_SOURCE;')
         self.dump('    out->MPI_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);')
         # Ignoring the private fields for now
         self.dump('}')
@@ -229,8 +232,11 @@ def generate_status_convert_fn_intern_to_abi(self):
         abi_type = self.mangle_name(type_)
         self.dump(f'{consts.INLINE_ATTRS} void {ConvertOMPIToStandard.STATUS}({abi_type} *out, {type_} *inp)')
         self.dump('{')
+        self.dump('    void *ptr = &out->MPI_Internal[1];')
         self.dump('    out->MPI_SOURCE = inp->MPI_SOURCE;')
         self.dump('    out->MPI_TAG = inp->MPI_TAG;')
+        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('}')
@@ -309,47 +315,72 @@ def dump_header(self):
     int MPI_SOURCE;
     int MPI_TAG;
     int MPI_ERROR;
-    int mpi_abi_private[5];
+    int MPI_Internal[5];
 };""")
         self.dump(f'typedef struct MPI_Status_ABI {self.mangle_name("MPI_Status")};')
         self.dump()
         # 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()
-            self.generate_comm_convert_fn()
-            self.generate_comm_convert_fn_intern_to_abi()
-            self.generate_info_convert_fn()
-            self.generate_info_convert_fn_intern_to_abi()
-            self.generate_file_convert_fn()
-            self.generate_file_convert_fn_intern_to_abi()
-            self.generate_group_convert_fn()
-            self.generate_group_convert_fn_intern_to_abi()
-            self.generate_datatype_convert_fn()
-            self.generate_datatype_convert_fn_intern_to_abi()
-            self.generate_errhandler_convert_fn()
-            self.generate_errhandler_convert_fn_intern_to_abi()
-            self.generate_message_convert_fn()
-            self.generate_message_convert_fn_intern_to_abi()
-            self.generate_op_convert_fn()
-            self.generate_op_convert_fn_intern_to_abi()
-            self.generate_session_convert_fn()
-            self.generate_session_convert_fn_intern_to_abi()
-            self.generate_win_convert_fn()
-            self.generate_win_convert_fn_intern_to_abi()
-            self.generate_request_convert_fn()
-            self.generate_request_convert_fn_intern_to_abi()
-            self.generate_status_convert_fn()
-            self.generate_status_convert_fn_intern_to_abi()
+
+#
+# the converters are no longer generated
+#
+#       if not self.external:
+#           # Now generate the conversion code
+#           self.generate_error_convert_fn()
+#           self.generate_comm_convert_fn()
+#           self.generate_comm_convert_fn_intern_to_abi()
+#           self.generate_info_convert_fn()
+#           self.generate_info_convert_fn_intern_to_abi()
+#           self.generate_file_convert_fn()
+#           self.generate_file_convert_fn_intern_to_abi()
+#           self.generate_group_convert_fn()
+#           self.generate_group_convert_fn_intern_to_abi()
+#           self.generate_datatype_convert_fn()
+#           self.generate_datatype_convert_fn_intern_to_abi()
+#           self.generate_errhandler_convert_fn()
+#           self.generate_errhandler_convert_fn_intern_to_abi()
+#           self.generate_message_convert_fn()
+#           self.generate_message_convert_fn_intern_to_abi()
+#           self.generate_op_convert_fn()
+#           self.generate_op_convert_fn_intern_to_abi()
+#           self.generate_session_convert_fn()
+#           self.generate_session_convert_fn_intern_to_abi()
+#           self.generate_win_convert_fn()
+#           self.generate_win_convert_fn_intern_to_abi()
+#           self.generate_request_convert_fn()
+#           self.generate_request_convert_fn_intern_to_abi()
+#           self.generate_status_convert_fn()
+#           self.generate_status_convert_fn_intern_to_abi()
 
         self.dump("""
 #if defined(c_plusplus) || defined(__cplusplus)
@@ -377,40 +408,66 @@ 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)
 
 
 ABI_INTERNAL_HEADER = 'ompi/mpi/c/abi.h'
+ABI_INTERNAL_CONVERTOR = 'ompi/mpi/c/abi_converters.h'
 
 
 def standard_abi(base_name, template, out):
     """Generate the standard ABI functions."""
     template.print_header(out)
     out.dump(f'#include "{ABI_INTERNAL_HEADER}"')
+    out.dump(f'#include "{ABI_INTERNAL_CONVERTOR}"')
+    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):
+        params = [param.construct(abi_type='standard') for param in template.prototype.params]
+        for param in params:
+            if param.callback_wrapper_code:
+                lines = []
+                lines.extend(param.callback_wrapper_code)
+                for line in lines:
+                    out.dump(line)
 
     # 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)