[PSyIR] translate the algorithm layer to PSyIR

[rupertford]

The algorithm layer is currently parsed and transformed with fparser2. We should use the PSyIR instead for flexibility and to support potential future optimisations. The idea would be to parse to low level PSyIR then to recognise invoke regions, Kernels and arguments with particular types (fields, scalars, ...) and have domain-specific nodes for these. In the first instance we would need to be able to re-create the existing algorithm transformation performed by fparser2.

Once the above is working then additional functionality to try to determine the datatypes, function spaces etc. of algorithm arguments (within invokes) that passed into the PSy-layer. This could then be used to perform static correctness checks between algorithm fields and kernel arguments (specified with metadata).

This would complement issue #79.

[arporter]

This issue will also remove the limitations we currently have on the form of arguments that can be passed in an Invoke. (e.g. specifying a stencil depth as an integer literal with explicit kind fails.)

[rupertford]

PSyIR has made significant progress and is nearly at the stage where PSyclone could use the PSyIR to translate and analyse the algorithm layer. The following code parses simple examples (obviously the filename and subroutine name needs setting appropriately):

from fparser.two.parser import ParserFactory
from fparser.common.readfortran import FortranFileReader
from psyclone.psyir.frontend.fparser2 import Fparser2Reader
from psyclone.psyir.backend.fortran import FortranWriter

# Parse code with fparser2
reader = FortranFileReader("alg.x90",
                           ignore_comments=True)
f2003_parser = ParserFactory().create(std="f2003")
parse_tree = f2003_parser(reader)

# Transform code from fparser2 to psyir
processor = Fparser2Reader()
name = "nonsense_alg"
container = processor.generate_container(parse_tree)
schedule = processor.generate_schedule(name, parse_tree, container=container)

# TODO transform from psyir to lfric algorithm psyir

# Take a look
container.view()

# TODO transform alg to processed alg

# print the transformed output
writer = FortranWriter()
code = writer(container)
print (code)

[rupertford]

Here is a list of known issues that need to be addressed/understood

1. calls are treated as codeblocks as the front-end does not yet parse them
2. Can we have a generic Fparser2Reader.generate() that just reads Fortran code, without the separate container and subroutine steps?
3. Seems to be a problem when leaving in comments
4. Test that code generated is correct for all LFRic algorithm files (run through this then parse again in the original way?)
5. Write psyir to lfric_algorithm_psyir transform
6. Transform algorithm invokes into their modified output
7. Integrate code into PSyclone (removing existing algorithm code (and classes - perhaps in two steps)

[rupertford]

[rupertford]

The above diagram is a summary of what we do at the moment for algorithm code and what I think we want to move to.

Alg() and Alg().gen() should be replaced with fparser2psyir and psyir2alg, with the Fortran backend generating the code.

The FileInfo class hierarchy that is produced by parse should be replaced with the alg psyir produced by psyir2alg. Note, an alternative to this would be to keep the FileInfo class hierarchy and add in any extra information that the PSy-layer might want e.g. datatypes, but I think the former is simpler and more powerful.

[rupertford]

Note the diagram above missed out a processing step (oops). alg.90 -> fparser2 ast -> psyir -> alg psyir -> processed alg psyir -> modified_alg.f90

[rupertford]

The first thing that is needed is a translation from psyir -> alg psyir. This requires new PSyIR subclasses to be created which provide at least as much information as the FileInfo hierarchy.

As fparser2 does not currently parse all invoke arguments correctly and the PSyIR does not support named arguments and structure constructors there has been a discussion about what the best way forward is. It has been agreed to continue with the original plan of translating from fparser2algast -> psyir - alg psyir which means that the translation from psyir to alg psyir will need to deal with information in code blocks and some incorrect psyir (structure constructors wrongly parsed as array references). This is OK as the psyir representation is not used anywhere else, it is just a stepping stone to alg psyir.

[rupertford]

Created branch 753_psyir_to_algpsyir