Generate bindings in one file

Author: jtronge

ompi/mpi/fortran/use-mpi-f08/Makefile.am

@@ -110,12 +110,6 @@ psizeof_f08.f90:
 
 CLEANFILES += sizeof_f08.h sizeof_f08.f90 psizeof_f08.f90
 
-mpi_api_generated_files = \
-        send_f08_generated.F90 \
-        send_f08_c_generated.F90 \
-        recv_f08_generated.F90 \
-        recv_f08_c_generated.F90 \
-        waitall_f08_generated.F90
 mpi_api_files = \
         abort_f08.F90 \
         accumulate_f08.F90 \
@@ -510,7 +504,7 @@ mpi_api_files = \
         win_unlock_f08.F90 \
         win_unlock_all_f08.F90 \
         win_wait_f08.F90 \
-        $(mpi_api_generated_files)
+        api_f08_generated.F90
 
 # JMS Somehow this variable substitution isn't quite working, and I
 # don't have time to figure it out.  So just wholesale copy the file
@@ -589,22 +583,18 @@ MAINTAINERCLEANFILES =
 # tarball
 EXTRA_DIST = \
         generate_bindings.py \
-        recv_f08.in \
-        send_f08.in \
-        waitall_f08.in
+        interface.in
 
 #
 # Generate the Fortran bindings and C wrapper functions for bindings with a
 # *.in template.
 #
 
 if OMPI_GENERATE_BINDINGS
-%_generated.F90: %.in generate_bindings.py
+api_f08_generated.F90: interface.in generate_bindings.py
 	$(PYTHON) $(srcdir)/generate_bindings.py fortran $< > $@
-%_c_generated.F90: %.in generate_bindings.py
-	$(PYTHON) $(srcdir)/generate_bindings.py fortran $< --bigcount > $@
 
-MAINTAINERCLEANFILES += $(mpi_api_generated_files)
+MAINTAINERCLEANFILES += api_f08_generated.F90
 endif
 
 ###########################################################################

ompi/mpi/fortran/use-mpi-f08/base/Makefile.am

@@ -32,19 +32,13 @@ noinst_LTLIBRARIES = libusempif08_ccode.la
 
 libusempif08_ccode_la_SOURCES = \
         buffer_detach.c \
-        send_f08_generated.c \
-        send_f08_c_generated.c \
-        recv_f08_generated.c \
-        recv_f08_c_generated.c \
-        waitall_f08_generated.c
+        api_f08_generated.c
 
 if OMPI_GENERATE_BINDINGS
-%_generated.c: ../%.in $(srcdir)/../generate_bindings.py
+api_f08_generated.c: ../interface.in $(srcdir)/../generate_bindings.py
 	$(PYTHON) $(srcdir)/../generate_bindings.py c $< > $@
-%_c_generated.c: ../%.in $(srcdir)/../generate_bindings.py
-	$(PYTHON) $(srcdir)/../generate_bindings.py c $< --bigcount > $@
 
-MAINTAINERCLEANFILES = send_f08_generated.c
+MAINTAINERCLEANFILES = api_f08_generated.c
 endif
 
 endif

ompi/mpi/fortran/use-mpi-f08/generate_bindings.py

@@ -6,6 +6,7 @@
 """
 from abc import ABC, abstractmethod
 import argparse
+from collections import namedtuple
 import re
 
 FORTRAN_ERROR_NAME = 'ierror'
@@ -378,47 +379,55 @@ def c_api_func_name_profile(fn_name, bigcount=False):
     return f'P{c_api_func_name(fn_name, bigcount)}'
 
 
-def print_header():
-    """Print the fortran f08 file header."""
-    print('#include "ompi/mpi/fortran/configure-fortran-output.h"')
-    print('#include "mpi-f08-rename.h"')
+FortranParameter = namedtuple('FortranParameter', ['type_', 'name', 'dep_name'])
+FortranPrototype = namedtuple('FortranPrototype', ['fn_name', 'parameters'])
 
 
-class FortranBinding:
-
-    def __init__(self, fname, bigcount=False):
-        self.bigcount = bigcount
-        with open(fname) as fp:
-            data = []
-            for line in fp:
-                data.append(line.strip())
-            data = ' '.join(data)
-            data = data.strip()
-            if PROTOTYPE_RE.match(data) is None:
-                raise PrototypeParseError('Invalid function prototype for Fortran interface')
-            start = data.index('(')
-            end = data.index(')')
-            self.fn_name = data[:start].strip()
-
-            parameters = data[start+1:end].split(',')
-            self.parameters = []
-            param_map = {}
-            dep_params = {}
+def load_prototypes(fname):
+    """Load the prototypes from a file."""
+    with open(fname) as fp:
+        prototypes = []
+        for i, line in enumerate(fp):
+            lno = i + 1
+            if PROTOTYPE_RE.match(line) is None:
+                raise PrototypeParseError(f'Invalid function prototype for Fortran interface on line {lno}')
+            start = line.index('(')
+            end = line.index(')')
+            fn_name = line[:start].strip()
+            parameters = line[start+1:end].split(',')
+            parsed_parameters = []
             for param in parameters:
                 param = param.strip()
                 type_, name = param.split()
-                type_ = FortranType.get(type_)
+                dep_name = None
                 # Check for 'param:other_param' parameters, indicating a
                 # dependency on that other parameter (such as for a count)
                 if ':' in name:
                     name, dep_name = name.split(':')
-                    dep_params[name] = dep_name
-                param = type_(name, self.fn_name, bigcount=bigcount)
-                self.parameters.append(param)
-                param_map[name] = param
-            # Set dependent parameters for those that need them
-            for name, dep_name in dep_params.items():
-                param_map[name].dep_param = param_map[dep_name]
+                parsed_parameters.append(FortranParameter(type_, name, dep_name))
+            prototypes.append(FortranPrototype(fn_name, parsed_parameters))
+        return prototypes
+
+
+class FortranBinding:
+    """Class for generating the binding for a single function."""
+
+    def __init__(self, prototype, bigcount=False):
+        self.bigcount = bigcount
+        self.fn_name = prototype.fn_name
+        self.parameters = []
+        param_map = {}
+        dep_params = {}
+        for param in prototype.parameters:
+            type_ = FortranType.get(param.type_)
+            param_type = type_(param.name, self.fn_name, bigcount=bigcount)
+            self.parameters.append(param_type)
+            param_map[param.name] = param_type
+            if param.dep_name is not None:
+                dep_params[param.name] = param.dep_name
+        # Set dependent parameters for those that need them
+        for name, dep_name in dep_params.items():
+            param_map[name].dep_param = param_map[dep_name]
 
     def _fn_name_suffix(self):
         """Return a suffix for function names."""
@@ -474,10 +483,6 @@ def _print_fortran_interface(self):
 
     def print_f_source(self):
         """Output the main MPI Fortran subroutine."""
-        print(f'! {GENERATED_MESSAGE}')
-
-        print_header()
-
         sub_name = self.fortran_f08_name
         c_func = self.c_func_name
         print('subroutine', f'{sub_name}({self._param_list()},{FORTRAN_ERROR_NAME})')
@@ -510,14 +515,6 @@ def print_f_source(self):
 
     def print_c_source(self):
         """Output the C source and function that the Fortran calls into."""
-        print(f'/* {GENERATED_MESSAGE} */')
-        print('#include "ompi_config.h"')
-        print('#include "mpi.h"')
-        print('#include "ompi/errhandler/errhandler.h"')
-        print('#include "ompi/mpi/fortran/mpif-h/status-conversion.h"')
-        print('#include "ompi/mpi/fortran/base/constants.h"')
-        print('#include "ompi/mpi/fortran/base/fint_2_int.h"')
-        print('#include "ompi/request/request.h"')
         parameters = [param.c_parameter() for param in self.parameters]
         # Always append the integer error
         parameters.append(f'MPI_Fint *{C_ERROR_NAME}')
@@ -565,18 +562,52 @@ def print_c_source(self):
         print('}')
 
 
+def print_f_source_header():
+    """Print the fortran f08 file header."""
+    print(f'! {GENERATED_MESSAGE}')
+    print('#include "ompi/mpi/fortran/configure-fortran-output.h"')
+    print('#include "mpi-f08-rename.h"')
+
+
+def print_c_source_header():
+    """Print the header of the C source file."""
+    print(f'/* {GENERATED_MESSAGE} */')
+    print('#include "ompi_config.h"')
+    print('#include "mpi.h"')
+    print('#include "ompi/errhandler/errhandler.h"')
+    print('#include "ompi/mpi/fortran/mpif-h/status-conversion.h"')
+    print('#include "ompi/mpi/fortran/base/constants.h"')
+    print('#include "ompi/mpi/fortran/base/fint_2_int.h"')
+    print('#include "ompi/request/request.h"')
+
+
+def print_binding(prototype, lang, bigcount=False):
+    """Print the binding with or without bigcount."""
+    binding = FortranBinding(prototype, bigcount=bigcount)
+    if lang == 'fortran':
+        binding.print_f_source()
+    else:
+        binding.print_c_source()
+
+
 def main():
     parser = argparse.ArgumentParser(description='generate fortran binding files')
-    parser.add_argument('lang', choices=('fortran', 'c'), help='generate dependent files in C or Fortran')
+    parser.add_argument('lang', choices=('fortran', 'c'),
+                        help='generate dependent files in C or Fortran')
     parser.add_argument('template', help='template file to use')
-    parser.add_argument('--bigcount', action='store_true', help='generate bigcount interface for function')
+    parser.add_argument('--bigcount', action='store_true',
+                        help='generate bigcount interface for function')
     args = parser.parse_args()
 
-    binding = FortranBinding(args.template, bigcount=args.bigcount)
+    prototypes = load_prototypes(args.template)
     if args.lang == 'fortran':
-        binding.print_f_source()
+        print_f_source_header()
     else:
-        binding.print_c_source()
+        print_c_source_header()
+    for prototype in prototypes:
+        print_binding(prototype, args.lang)
+        if any(param.type_ == 'COUNT' for param in prototype.parameters):
+            print_binding(prototype, args.lang, bigcount=True)
 
 
 if __name__ == '__main__':

ompi/mpi/fortran/use-mpi-f08/interface.in

@@ -0,0 +1,3 @@
+recv(BUFFER buf, COUNT count, DATATYPE datatype, RANK source, TAG tag, COMM comm, STATUS status)
+send(BUFFER buf, COUNT count, DATATYPE datatype, RANK dest, TAG tag, COMM comm)
+waitall(SHORTCUT_COUNT count, REQUEST_ARRAY array_of_requests:count, STATUS_ARRAY array_of_statuses:count)