use-mpi-ignore: start using binding infrastructure

for new fortran methods

starting with MPI_Request_get_status_(any/all/some) plus
switch MPI_Request_get_status to use the binding
infrastructure as well.

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

Author: hppritcha

.gitignore

@@ -539,3 +539,5 @@ ompi/mpi/c/*_generated*.c
 ompi/mpi/fortran/use-mpi-f08/*_generated.F90
 ompi/mpi/fortran/use-mpi-f08/base/*_generated.c
 ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces-generated.h
+ompi/mpi/fortran/use-mpi-ignore-tkr/mpi-ignore-tkr-interfaces-generated.h
+ompi/mpi/fortran/use-mpi-ignore-tkr/*_generated.F90

ompi/mpi/bindings/bindings.py

@@ -37,12 +37,16 @@ def main():
     subparsers_fortran = parser_fortran.add_subparsers()
     parser_code = subparsers_fortran.add_parser('code', help='generate binding code')
     parser_code.set_defaults(handler=lambda args, out: fortran.generate_code(args, out))
-    parser_code.add_argument('--lang', choices=('fortran', 'c'),
+    parser_code.add_argument('--lang', choices=('fortran', 'c', 'f90'),
                              help='language to generate (only for code subparser)')
+    parser_code.add_argument('--fort-std', choices=('f90', 'f08'),
+                             help='fortran standard to use for fortran module generation')
     # Handler for generating the Fortran interface files
     parser_interface = subparsers_fortran.add_parser('interface',
                                                      help='generate Fortran interface specifications')
     parser_interface.set_defaults(handler=lambda args, out: fortran.generate_interface(args, out))
+    parser_interface.add_argument('--fort-std', choices=('f90', 'f08'),
+                             help='fortran standard to use for fortran module generation')
     # The prototype files argument must come last and be specified for both subparsers
     for f_subparser in [parser_code, parser_interface]:
         f_subparser.add_argument('--prototype-files', nargs='+', help='prototype files to generate code for')

ompi/mpi/bindings/ompi_bindings/fortran.py

@@ -25,17 +25,19 @@
 class FortranBinding:
     """Class for generating the binding for a single function."""
 
-    def __init__(self, prototype, out, template=None, bigcount=False, needs_ts=False):
+    def __init__(self, prototype, out, template=None, bigcount=False, needs_ts=False, gen_f90=False):
         # Generate bigcount interface version
         self.bigcount = bigcount
         self.fn_name = template.prototype.name
         self.out = out
         self.template = template
         self.needs_ts = needs_ts
+        self.gen_f90 = gen_f90
         self.parameters = []
         for param in self.template.prototype.params:
             self.parameters.append(param.construct(fn_name=self.fn_name,
-                                                   bigcount=bigcount))
+                                                   bigcount=bigcount,
+                                                   gen_f90=gen_f90))
 
     def dump(self, *pargs, **kwargs):
         """Write to the output file."""
@@ -74,6 +76,19 @@ def _use_stmts(self):
             stmts.append(f'use :: {mod}, only: {names}')
         return stmts
 
+    def _include_stmts(self):
+        """Return a list of required includes needed."""
+        includes = []
+        names = []
+        for param in self.parameters:
+            name = param.include()
+            if name != '':
+                if name in names:
+                    continue
+                includes.append(f'include \'{name}\'')
+                names.append(f'{name}')
+        return includes
+
     def _print_fortran_interface(self):
         """Output the C subroutine binding for the Fortran code."""
         name = self.c_func_name
@@ -92,6 +107,9 @@ def _print_fortran_interface(self):
         for stmt in use_stmts:
             self.dump(f'            {stmt}')
         self.dump('            implicit none')
+        include_stmts = self._include_stmts()
+        for stmt in include_stmts:
+            self.dump(f'            {stmt}')
         for param in self.parameters:
             self.dump(f'            {param.declare_cbinding_fortran()}')
         self.dump(f'            INTEGER, INTENT(OUT) :: {consts.FORTRAN_ERROR_NAME}')
@@ -108,17 +126,24 @@ def _print_fortran_header(self, is_interface=False):
         for stmt in use_stmts:
             self.dump(f'    {stmt}')
         self.dump('    implicit none')
+        # Include statements
+        include_stmts = self._include_stmts()
+        for stmt in include_stmts:
+            self.dump(f'    {stmt}')
         # Parameters/dummy variable declarations
         for param in self.parameters:
             if is_interface:
                 self.dump_lines(param.interface_predeclare())
             self.dump_lines(param.declare())
         # Add the integer error manually
-        self.dump(f'    INTEGER, OPTIONAL, INTENT(OUT) :: {consts.FORTRAN_ERROR_NAME}')
+        if self.gen_f90 == True:
+            self.dump(f'    INTEGER, INTENT(OUT) :: {consts.FORTRAN_ERROR_NAME}')
+        else:
+            self.dump(f'    INTEGER, OPTIONAL, INTENT(OUT) :: {consts.FORTRAN_ERROR_NAME}')
 
     def _print_fortran_subroutine(self):
         """Output the Fortran subroutine line."""
-        sub_name = util.fortran_f08_name(self.fn_name, bigcount=self.bigcount, needs_ts=self.needs_ts)
+        sub_name = util.fortran_name(self.fn_name, bigcount=self.bigcount, gen_f90=self.gen_f90, needs_ts=self.needs_ts)
         params = [param.name for param in self.parameters]
         params.append(consts.FORTRAN_ERROR_NAME)
         lines = util.break_param_lines_fortran(f'subroutine {sub_name}(', params, ')')
@@ -127,7 +152,7 @@ def _print_fortran_subroutine(self):
 
     def _print_fortran_subroutine_end(self):
         """Output the Fortran end subroutine line."""
-        sub_name = util.fortran_f08_name(self.fn_name, bigcount=self.bigcount, needs_ts=self.needs_ts)
+        sub_name = util.fortran_name(self.fn_name, bigcount=self.bigcount, gen_f90=self.gen_f90, needs_ts=self.needs_ts)
         self.dump(f'end subroutine {sub_name}')
 
     def dump_lines(self, line_text):
@@ -210,18 +235,20 @@ def print_profiling_rename_macros(templates, out, args):
 
     Previously hardcoded in mpi-f08-rename.h.
     """
+    gen_f90 = True if args.fort_std == 'f90' else False
     out.dump('#if OMPI_BUILD_MPI_PROFILING')
     for template in templates:
         has_buffers = util.prototype_has_buffers(template.prototype)
         needs_ts = has_buffers and args.generate_ts_suffix
-        name = util.fortran_f08_name(template.prototype.name, needs_ts=needs_ts)
+        name = util.fortran_name(template.prototype.name, gen_f90=gen_f90, needs_ts=needs_ts)
         out.dump(f'#define {name} P{name}')
         # Check for bigcount version
         if util.prototype_has_bigcount(template.prototype):
-            bigcount_name = util.fortran_f08_name(template.prototype.name, bigcount=True, needs_ts=needs_ts)
+            bigcount_name = util.fortran_name(template.prototype.name, bigcount=True, needs_ts=needs_ts)
             out.dump(f'#define {bigcount_name} P{bigcount_name}')
-        name = util.fortran_f08_generic_interface_name(template.prototype.name)
-        out.dump(f'#define {name} P{name}')
+        if gen_f90 == False:
+            name = util.fortran_f08_generic_interface_name(template.prototype.name)
+            out.dump(f'#define {name} P{name}')
     out.dump('#endif /* OMPI_BUILD_MPI_PROFILING */')
 
 
@@ -246,9 +273,9 @@ def print_c_source_header(out):
     out.dump('#include "bigcount.h"')
 
 
-def print_binding(prototype, lang, out, bigcount=False, template=None, needs_ts=False):
+def print_binding(prototype, lang, out, bigcount=False, template=None, needs_ts=False, gen_f90=False):
     """Print the binding with or without bigcount."""
-    binding = FortranBinding(prototype, out=out, bigcount=bigcount, template=template, needs_ts=needs_ts)
+    binding = FortranBinding(prototype, out=out, bigcount=bigcount, template=template, needs_ts=needs_ts, gen_f90=gen_f90)
     if lang == 'fortran':
         binding.print_f_source()
     else:
@@ -267,6 +294,11 @@ def generate_code(args, out):
     """Generate binding code based on arguments."""
     templates = load_function_templates(args.prototype_files)
 
+    if args.fort_std == 'f08' or args.fort_std == None:
+        gen_f90 = False
+    else:
+        gen_f90 = True
+
     if args.lang == 'fortran':
         print_f_source_header(out)
         out.dump()
@@ -279,8 +311,8 @@ def generate_code(args, out):
         out.dump()
         has_buffers = util.prototype_has_buffers(template.prototype)
         needs_ts = has_buffers and args.generate_ts_suffix
-        print_binding(template.prototype, args.lang, out, template=template, needs_ts=needs_ts)
-        if util.prototype_has_bigcount(template.prototype):
+        print_binding(template.prototype, args.lang, out, template=template, needs_ts=needs_ts, gen_f90=gen_f90)
+        if util.prototype_has_bigcount(template.prototype) and gen_f90 == False:
             out.dump()
             print_binding(template.prototype, args.lang, bigcount=True, out=out, template=template, needs_ts=needs_ts)
 
@@ -292,14 +324,19 @@ def generate_interface(args, out):
     templates = load_function_templates(args.prototype_files)
     print_profiling_rename_macros(templates, out, args)
 
+    if args.fort_std == 'f08' or args.fort_std == None:
+        gen_f90 = False
+    else:
+        gen_f90 = True
+
     for template in templates:
         ext_name = util.ext_api_func_name(template.prototype.name)
         out.dump(f'interface {ext_name}')
         has_buffers = util.prototype_has_buffers(template.prototype)
         needs_ts = has_buffers and args.generate_ts_suffix
-        binding = FortranBinding(template.prototype, template=template, needs_ts=needs_ts, out=out)
+        binding = FortranBinding(template.prototype, template=template, needs_ts=needs_ts, gen_f90=gen_f90, out=out)
         binding.print_interface()
-        if util.prototype_has_bigcount(template.prototype):
+        if util.prototype_has_bigcount(template.prototype) and gen_f90 == False:
             out.dump()
             binding_c = FortranBinding(template.prototype, out=out, template=template,
                                        needs_ts=needs_ts, bigcount=True)