def test_long_lines_false(): ''' Tests that the long_lines method returns false with fortran input which has all lines shorter than the specified maximum''' input_string = ("! line1\n" "! " + "line2" * 5 + "\n" + "! line3\n") fll = FortLineLength(line_length=30) assert not fll.long_lines(input_string),\ "long_lines_false test should return False"
def test_comment(): ''' Tests that a long comment line wrapped as expected ''' input_file = " ! this is a comment" expected_output = " ! this is a \n!& comment" fll = FortLineLength(line_length=len(input_file) - 5) output_file = fll.process(input_file) assert output_file == expected_output
def test_multiple_lines_comment(): ''' test that multiple lines works as expected for comments ''' input_file = ("! blahdeblah, blahdeblah, blahdeblah, blahdeblah\n") expected_output = ( "! blahdeblah, \n!& blahdeblah, \n!& blahdeblah, \n!& blahdeblah\n") fll = FortLineLength(line_length=18) output_file = fll.process(input_file) assert output_file == expected_output
def test_fail_to_wrap(): ''' Tests that we raise an error if we can't find anywhere to wrap the line''' input_file = "!$OMPPARALLELDO" with pytest.raises(Exception) as excinfo: fll = FortLineLength(line_length=len(input_file) - 1) _ = fll.process(input_file) assert 'No suitable break point found' in str(excinfo.value)
def test_acc_directive(): ''' Tests that we deal with an OpenACC directive appropriately when its needs to be line wrapped ''' input_file = " !$ACC kernels loop gang(32), vector(16)\n" expected_output = " !$ACC kernels loop gang(32), &\n!$acc& vector(16)\n" fll = FortLineLength(line_length=len(input_file) - 5) output_file = fll.process(input_file) assert output_file == expected_output
def test_long_lines_true(): ''' Tests that the long_lines method returns true with fortran input which has at least one line longer than the specified maximum''' input_string = ("! line1\n" "! " + "line2" * 6 + "\n" "! line3\n") fll = FortLineLength(line_length=30) assert fll.long_lines(input_string),\ "long_lines_true test should return True"
def test_wrapped(): ''' Tests that a file whose lines are longer than the specified line length is wrapped appropriately by the FortLineLength class ''' fll = FortLineLength(line_length=30) output_file = fll.process(INPUT_FILE) print "(" + EXPECTED_OUTPUT + ")" print "(" + output_file + ")" assert output_file == EXPECTED_OUTPUT, "output and expected output differ "
def test_openmp_directive(): ''' Tests that we successfully break an OpenMP directive line on a space ''' input_file = " !$OMP PARALLEL LOOP\n" expected_output = " !$OMP PARALLEL &\n!$omp& LOOP\n" fll = FortLineLength(line_length=len(input_file) - 3) output_file = fll.process(input_file) assert output_file == expected_output
def _code_compiles(self, psy_ast): '''Attempts to build the Fortran code supplied as an AST of f2pygen objects. Returns True for success, False otherwise. It is meant for internal test uses only, and must only be called when compilation is actually enabled (use code_compiles otherwse). All files produced are deleted. :param psy_ast: The AST of the generated PSy layer :type psy_ast: Instance of :py:class:`psyclone.psyGen.PSy` :return: True if generated code compiles, False otherwise :rtype: bool ''' kernel_modules = set() # Get the names of the modules associated with the kernels. # By definition, built-ins do not have associated Fortran modules. for invoke in psy_ast.invokes.invoke_list: for call in invoke.schedule.coded_kernels(): kernel_modules.add(call.module_name) # Change to the temporary directory passed in to us from # pytest. (This is a LocalPath object.) old_pwd = self._tmpdir.chdir() # Create a file containing our generated PSy layer. psy_filename = "psy.f90" with open(psy_filename, 'w') as psy_file: # We limit the line lengths of the generated code so that # we don't trip over compiler limits. from psyclone.line_length import FortLineLength fll = FortLineLength() psy_file.write(fll.process(str(psy_ast.gen))) success = True try: # Build the kernels. We allow kernels to also be located in # the temporary directory that we have been passed. for fort_file in kernel_modules: # Skip file if it is not Fortran. TODO #372: Add support # for C/OpenCL compiling as part of the test suite. if fort_file.endswith(".cl"): continue name = self.find_fortran_file( [self.base_path, str(self._tmpdir)], fort_file) self.compile_file(name) # Finally, we can build the psy file we have generated self.compile_file(psy_filename) except CompileError: # Failed to compile one of the files success = False finally: old_pwd.chdir() return success
def test_multiple_lines_acc(): ''' test that multiple lines works as expected for OpenACC directives ''' input_file = ("!$acc blahdeblah, blahdeblah, blahdeblah, blahdeblah\n") expected_output = ( "!$acc blahdeblah, &\n!$acc& blahdeblah, &\n!$acc& blahdeblah," " &\n!$acc& blahdeblah\n") fll = FortLineLength(line_length=24) output_file = fll.process(input_file) assert output_file == expected_output
def test_multiple_lines_statements(): ''' test that multiple lines works as expected for statements (INTEGER, REAL, TYPE, CALL, SUBROUTINE and USE) ''' input_file = ("INTEGER blahdeblah, blahdeblah, blahdeblah, blahdeblah\n") expected_output = ( "INTEGER &\n&blahdeblah, &\n&blahdeblah, &\n&blahdeblah," " &\n&blahdeblah\n") fll = FortLineLength(line_length=18) output_file = fll.process(input_file) assert output_file == expected_output
def test_wrapped_lower(): ''' Tests that a lower case file whose lines are longer than the specified line length is wrapped appropriately by the FortLineLength class''' fll = FortLineLength(line_length=30) output_file = fll.process(INPUT_FILE.lower()) print("(" + EXPECTED_OUTPUT.lower() + ")") print("(" + output_file + ")") assert output_file == EXPECTED_OUTPUT.lower(), \ "output and expected output differ "
def test_exception_line_too_long(): ''' Test that output lines are not longer than the maximum specified''' input_file = ("INTEGER stuffynostrils, blahdeblah,blahdeblah blahdeblah\n" "!$omp stuffynostrils,(blahdeblah)blahdeblah=(blahdeblah)\n" "!$acc stuffynostrils,(blahdeblah)blahdeblah=(blahdeblah)\n" "! stuffynostrils,blahdeblah.blahdeblah blahdeblah).\n") fll = FortLineLength(line_length=24) output_file = fll.process(input_file) for line in output_file.split('\n'): assert len(line) <= 24, \ "Error, output line is longer than the maximum allowed"
def test_long_line_continuator(): '''Tests that an input algorithm file with long lines of a type not recognised by FortLineLength (assignments in this case), which already have continuators to make the code conform to the line length limit, does not cause an error. ''' alg, _ = generate(os.path.join(os.path.dirname(os.path.abspath(__file__)), "test_files", "dynamo0p3", "13.2_alg_long_line_continuator.f90"), api="dynamo0.3") input_string = str(alg) fll = FortLineLength() _ = fll.process(input_string)
def run(): ''' Top-level driver for the kernel-stub generator. Handles command-line flags, calls generate() and applies line-length limiting to the output (if requested). ''' import argparse parser = argparse.ArgumentParser(description="Create Kernel stub code from" " Kernel metadata") parser.add_argument("-o", "--outfile", help="filename of output") parser.add_argument( "-api", default=Config.get().default_stub_api, help="choose a particular api from {0}, default {1}".format( str(Config.get().supported_stub_apis), Config.get().default_stub_api)) parser.add_argument('filename', help='Kernel metadata') parser.add_argument('-l', '--limit', dest='limit', action='store_true', default=False, help='limit the fortran line length to 132 characters') args = parser.parse_args() try: stub = generate(args.filename, api=args.api) except (IOError, ParseError, GenerationError, RuntimeError) as error: print("Error:", error) exit(1) except Exception as error: # pylint: disable=broad-except print("Error, unexpected exception:\n") exc_type, exc_value, exc_traceback = sys.exc_info() print(exc_type) print(exc_value) traceback.print_tb(exc_traceback) exit(1) if args.limit: fll = FortLineLength() stub_str = fll.process(str(stub)) else: stub_str = str(stub) if args.outfile is not None: my_file = open(args.outfile, "w") my_file.write(stub_str) my_file.close() else: print("Kernel stub code:\n", stub_str)
def test_length(): ''' Tests that the length method returns the expected value ''' input_length = 20 fll = FortLineLength(line_length=input_length) output_length = fll.length assert output_length == input_length,\ "test_length expecting length method to be the same as the length" +\ "provided on input"
def test_unchanged(): ''' Tests that a file whose lines are shorter than the specified line length is unchanged by the FortLineLength class ''' input_file = (" INTEGER stuff\n" " REAL stuff\n" " TYPE stuff\n" " CALL stuff\n" " SUBROUTINE stuff\n" " USE stuff\n" " !$OMP stuff\n" " !$ACC stuff\n" " ! stuff\n" " stuff\n") fll = FortLineLength(line_length=25) output_file = fll.process(input_file) print "(" + input_file + ")" print "(" + output_file + ")" assert input_file == output_file, "input should remain unchanged"
def test_edge_conditions_comments(): '''Test that we get correct behaviour with comments when the input line equals the max line length, or multiples thereof and lengths one larger and one smaller. This is to make sure we don't have issues like ending up with a continuation but no following line.''' input_string = ("! COMMENT COMME\n" "! COMMENT COMMEN\n" "! COMMENT COMMENT\n" "! COMMENT COMMENT COMME\n" "! COMMENT COMMENT COMMEN\n" "! COMMENT COMMENT COMMENT\n") expected_output = ("! COMMENT COMME\n" "! COMMENT COMMEN\n" "! COMMENT \n!& COMMENT\n" "! COMMENT \n!& COMMENT COMME\n" "! COMMENT \n!& COMMENT COMMEN\n" "! COMMENT \n!& COMMENT \n!& COMMENT\n") fll = FortLineLength(line_length=len("! COMMENT COMMEN")) output_string = fll.process(input_string) assert output_string == expected_output
def check_line_length(filename): '''Check that the code contained within the filename file conforms to the 132 line length limit. :param str filename: The file containing the code. :raises InternalError: if the specified file can not be opened or read. :raises ParseError: if one of more lines are longer than the 132 \ line length limit. ''' fll = FortLineLength() try: with io.open(filename, "r", encoding='utf8') as myfile: code_str = myfile.read() except IOError as excinfo: raise InternalError("In utils.py:check_line_length: {0}".format( str(excinfo))) if fll.long_lines(code_str): raise ParseError("the file does not conform to the specified {0} line " "length limit".format(str(fll.length)))
def test_edge_conditions_omp(): '''Test that we get correct behaviour using OpenMP directives when the input line equals the max line length, or multiples thereof and lengths one larger and one smaller. This is to make sure we don't have issues like ending up with a continuation but no following line. ''' input_string = ("!$OMP OPENMP OPEN\n" "!$OMP OPENMP OPENM\n" "!$OMP OPENMP OPENMP\n" "!$OMP OPENMP OPENMP OPEN\n" "!$OMP OPENMP OPENMP OPENM\n" "!$OMP OPENMP OPENMP OPENMP\n") expected_output = ("!$OMP OPENMP OPEN\n" "!$OMP OPENMP OPENM\n" "!$OMP OPENMP &\n!$omp& OPENMP\n" "!$OMP OPENMP &\n!$omp& OPENMP OPEN\n" "!$OMP OPENMP &\n!$omp& OPENMP OPENM\n" "!$OMP OPENMP &\n!$omp& OPENMP &\n!$omp& OPENMP\n") fll = FortLineLength(line_length=len("!$OMP OPENMP OPENM")) output_string = fll.process(input_string) assert output_string == expected_output
def test_break_types_multi_line(): ''' Test the different supported line breaks.''' input_file = ("INTEGER stuffynostrils, blahdeblah,blahdeblah blahdeblah\n" "!$omp stuffynostrils,(blahdeblah)blahdeblah=(blahdeblah)\n" "!$acc stuffynostrils,(blahdeblah)blahdeblah=(blahdeblah)\n" "! stuffynostrils,blahdeblah.blahdeblah blahdeblah).\n") expected_output = ( "INTEGER stuffynostrils,&\n& blahdeblah,&\n&blahdeblah" " blahdeblah\n" "!$omp &\n!$omp& stuffynostrils, &\n!$omp& (blahdeblah) &\n!$omp&" " blahdeblah= &\n!$omp& (blahdeblah)\n" "!$acc &\n!$acc& stuffynostrils, &\n!$acc& (blahdeblah) &\n!$acc&" " blahdeblah= &\n!$acc& (blahdeblah)\n" "! \n!& stuffynostrils,\n!& blahdeblah.\n!& blahdeblah \n!&" " blahdeblah).\n") fll = FortLineLength(line_length=24) output_file = fll.process(input_file) print "(" + output_file + ")" print expected_output assert output_file == expected_output
def test_edge_conditions_statements(): ''' Test that we get correct behaviour using statements (INTEGER, REAL, TYPE, CALL, SUBROUTINE and USE) when the input line equals the max line length, or multiples thereof and lengths one larger and one smaller. This is to make sure we don't have issues like ending up with a continuation but no following line.''' input_string = ("INTEGER INTEG\n" "INTEGER INTEGE\n" "INTEGER INTEGER\n") expected_output = ("INTEGER INTEG\n" "INTEGER INTEGE\n" "INTEGER &\n&INTEGER\n") fll = FortLineLength(line_length=len("INTEGER INTEGE")) output_string = fll.process(input_string) print output_string print expected_output assert output_string == expected_output input_string = ("INTEGER INTEGER INTEG\n" "INTEGER INTEGER INTEGE\n" "INTEGER INTEGER INTEGER\n") expected_output = ("INTEGER &\n&INTEGER INTEG\n" "INTEGER &\n&INTEGER INTEGE\n" "INTEGER &\n&INTEGER &\n&INTEGER\n") fll = FortLineLength(line_length=len("INTEGER INTEGER")) output_string = fll.process(input_string) print output_string print expected_output assert output_string == expected_output
''' Script to demonstrate the use on the line wrapping support in PSyclone''' from __future__ import print_function from psyclone.generator import generate from psyclone.line_length import FortLineLength # long_lines=True checks whether the input fortran conforms to the 132 line # length limit ALG, PSY = generate( "longlines.f90", kernel_path="../../src/psyclone/tests/test_files/dynamo0p3", line_length=True) LINE_LENGTH = FortLineLength() ALG_STR = LINE_LENGTH.process(str(ALG)) print(ALG_STR) PSY_STR = LINE_LENGTH.process(str(PSY)) print(PSY_STR)
def code_compiles(api, psy_ast, tmpdir, f90, f90flags): '''Attempts to build the Fortran code supplied as an AST of f2pygen objects. Returns True for success, False otherwise. If no Fortran compiler is available then returns True. All files produced are deleted. :param api: Which PSyclone API the supplied code is using :type api: string :param psy_ast: The AST of the generated PSy layer :type psy_ast: Instance of :py:class:`psyGen.PSy` :param tmpdir: py.test-supplied temporary directory. Can contain \ transformed kernel source. :type tmpdir: :py:class:`LocalPath` :param f90: The command to invoke the Fortran compiler :type f90: string :param f90flags: Flags to pass to the Fortran compiler :type f90flags: string :return: True if generated code compiles, False otherwise :rtype: bool ''' if not TEST_COMPILE: # Compilation testing is not enabled return True # API-specific set-up - where to find infrastructure source files # and which ones to build supported_apis = ["dynamo0.3"] if api not in supported_apis: raise CompileError("Unsupported API in code_compiles. Got {0} but " "only support {1}".format(api, supported_apis)) if api == "dynamo0.3": base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test_files", "dynamo0p3") from dynamo0p3_build import INFRASTRUCTURE_MODULES as module_files kernel_modules = set() # Get the names of the modules associated with the kernels. By definition, # built-ins do not have associated Fortran modules. for invoke in psy_ast.invokes.invoke_list: for call in invoke.schedule.kern_calls(): kernel_modules.add(call.module_name) # Change to the temporary directory passed in to us from # pytest. (This is a LocalPath object.) old_pwd = tmpdir.chdir() # Create a file containing our generated PSy layer. psy_filename = "psy.f90" with open(psy_filename, 'w') as psy_file: # We limit the line lengths of the generated code so that # we don't trip over compiler limits. from psyclone.line_length import FortLineLength fll = FortLineLength() psy_file.write(fll.process(str(psy_ast.gen))) # Infrastructure modules are in the 'infrastructure' directory module_path = os.path.join(base_path, "infrastructure") kernel_path = base_path success = False try: # First build the infrastructure modules for fort_file in module_files: name = find_fortran_file([module_path], fort_file) # We don't have to copy the source file - just compile it in the # current working directory. success = compile_file(name, f90, f90flags) # Next, build the kernels. We allow kernels to also be located in # the temporary directory that we have been passed. for fort_file in kernel_modules: name = find_fortran_file([kernel_path, str(tmpdir)], fort_file) success = compile_file(name, f90, f90flags) # Finally, we can build the psy file we have generated success = compile_file(psy_filename, f90, f90flags) except CompileError: # Failed to compile one of the files success = False finally: # Clean-up - delete all generated files. This permits this routine # to be called multiple times from within the same test. os.chdir(str(old_pwd)) for ofile in tmpdir.listdir(): ofile.remove() return success
def parse(alg_filename, api="", invoke_name="invoke", inf_name="inf", kernel_path="", line_length=False, distributed_memory=config.DISTRIBUTED_MEMORY): '''Takes a GungHo algorithm specification as input and outputs an AST of this specification and an object containing information about the invocation calls in the algorithm specification and any associated kernel implementations. :param str alg_filename: The file containing the algorithm specification. :param str invoke_name: The expected name of the invocation calls in the algorithm specification :param str inf_name: The expected module name of any required infrastructure routines. :param str kernel_path: The path to search for kernel source files (if different from the location of the algorithm source). :param bool line_length: A logical flag specifying whether we care about line lengths being longer than 132 characters. If so, the input (algorithm and kernel) code is checked to make sure that it conforms and an error raised if not. The default is False. :rtype: ast,invoke_info :raises IOError: if the filename or search path does not exist :raises ParseError: if there is an error in the parsing :raises RuntimeError: if there is an error in the parsing For example: >>> from parse import parse >>> ast,info=parse("argspec.F90") ''' if distributed_memory not in [True, False]: raise ParseError( "The distributed_memory flag in parse() must be set to" " 'True' or 'False'") config.DISTRIBUTED_MEMORY = distributed_memory if api == "": from psyclone.config import DEFAULTAPI api = DEFAULTAPI else: check_api(api) # Get the names of the supported Built-in operations for this API builtin_names, builtin_defs_file = get_builtin_defs(api) # drop cache fparser1.parsefortran.FortranParser.cache.clear() fparser.logging.disable('CRITICAL') if not os.path.isfile(alg_filename): raise IOError("File %s not found" % alg_filename) try: ast = fpapi.parse(alg_filename, ignore_comments=False, analyze=False) # ast includes an extra comment line which contains file # details. This line can be long which can cause line length # issues. Therefore set the information (name) to be empty. ast.name = "" except: import traceback traceback.print_exc() raise ParseError("Fatal error in external fparser tool") if line_length: fll = FortLineLength() with open(alg_filename, "r") as myfile: code_str = myfile.read() if fll.long_lines(code_str): raise ParseError( "parse: the algorithm file does not conform to the specified" " {0} line length limit".format(str(fll.length))) name_to_module = {} try: from collections import OrderedDict except: try: from ordereddict import OrderedDict except: import sys python_version = sys.version_info if python_version[0] <= 2 and python_version[1] < 7: raise ParseError( "OrderedDict not provided natively pre python 2.7 " "(you are running {0}. Try installing with 'sudo " "pip install ordereddict'".format(python_version)) else: raise ParseError( "OrderedDict not found which is unexpected as it is " "meant to be part of the Python library from 2.7 onwards") invokecalls = OrderedDict() # Keep a list of the named invokes so that we can check that the same # name isn't used more than once unique_invoke_labels = [] container_name = None for child in ast.content: if isinstance(child, fparser1.block_statements.Program) or \ isinstance(child, fparser1.block_statements.Module) or \ isinstance(child, fparser1.block_statements.Subroutine): container_name = child.name break if container_name is None: raise ParseError( "Error, program, module or subroutine not found in ast") for statement, depth in fpapi.walk(ast, -1): if isinstance(statement, fparser1.statements.Use): for name in statement.items: name_to_module[name] = statement.name if isinstance(statement, fparser1.statements.Call) \ and statement.designator == invoke_name: statement_kcalls = [] invoke_label = None for arg in statement.items: # We expect each item in an invoke call to be either a # call to a kernel or the name of the invoke (specifed # as name="my_name") try: parsed = expr.FORT_EXPRESSION.parseString(arg)[0] except ParseException: raise ParseError("Failed to parse string: {0}".format(arg)) if isinstance(parsed, expr.NamedArg): if parsed.name.lower() != "name": raise ParseError( "The arguments to an invoke() must be either " "kernel calls or an (optional) name='invoke-name' " "but got '{0}' in file {1}".format( str(parsed), alg_filename)) if invoke_label: raise ParseError( "An invoke must contain one or zero 'name=xxx' " "arguments but found more than one in: {0} in " "file {1}".format(str(statement), alg_filename)) if not parsed.is_string: raise ParseError( "The (optional) name of an invoke must be " "specified as a string but got {0} in file {1}.". format(str(parsed), alg_filename)) # Store the supplied label. Use lower-case (as Fortran # is case insensitive) invoke_label = parsed.value.lower() # Remove any spaces. # TODO check with LFRic team - should we raise an error if # it contains spaces? invoke_label = invoke_label.replace(" ", "_") # Check that the resulting label is a valid Fortran Name from fparser.two import pattern_tools if not pattern_tools.abs_name.match(invoke_label): raise ParseError( "The (optional) name of an invoke must be a " "string containing a valid Fortran name (with " "any spaces replaced by underscores) but " "got '{0}' in file {1}".format( invoke_label, alg_filename)) # Check that it's not already been used in this Algorithm if invoke_label in unique_invoke_labels: raise ParseError( "Found multiple named invoke()'s with the same " "name ('{0}') when parsing {1}".format( invoke_label, alg_filename)) unique_invoke_labels.append(invoke_label) # Continue parsing the other arguments to this invoke call continue argname = parsed.name argargs = [] for a in parsed.args: if type(a) is str: # a literal is being passed by argument argargs.append(Arg('literal', a)) else: # assume argument parsed as a FunctionVar variableName = a.name if a.args is not None: # argument is an indexed array so extract the # full text fullText = "" for tok in a.walk_skipping_name(): fullText += str(tok) argargs.append( Arg('indexed_variable', fullText, variableName)) else: # argument is a standard variable argargs.append( Arg('variable', variableName, variableName)) if argname in builtin_names: if argname in name_to_module: raise ParseError("A built-in cannot be named in a use " "statement but '{0}' is used from " "module '{1}' in file {2}".format( argname, name_to_module[argname], alg_filename)) # this is a call to a built-in operation. The # KernelTypeFactory will generate appropriate meta-data statement_kcalls.append( BuiltInCall( BuiltInKernelTypeFactory(api=api).create( builtin_names, builtin_defs_file, name=argname), argargs)) else: try: modulename = name_to_module[argname] except KeyError: raise ParseError( "kernel call '{0}' must either be named in a use " "statement or be a recognised built-in " "(one of '{1}' for this API)".format( argname, builtin_names)) # Search for the file containing the kernel source import fnmatch # We only consider files with the suffixes .f90 and .F90 # when searching for the kernel source. search_string = "{0}.[fF]90".format(modulename) # Our list of matching files (should have length == 1) matches = [] # If a search path has been specified then we look there. # Otherwise we look in the directory containing the # algorithm definition file if len(kernel_path) > 0: cdir = os.path.abspath(kernel_path) if not os.access(cdir, os.R_OK): raise IOError( "Supplied kernel search path does not exist " "or cannot be read: {0}".format(cdir)) # We recursively search down through the directory # tree starting at the specified path if os.path.exists(cdir): for root, dirnames, filenames in os.walk(cdir): for filename in fnmatch.filter( filenames, search_string): matches.append(os.path.join( root, filename)) else: # We look *only* in the directory that contained the # algorithm file cdir = os.path.abspath(os.path.dirname(alg_filename)) filenames = os.listdir(cdir) for filename in fnmatch.filter(filenames, search_string): matches.append(os.path.join(cdir, filename)) # Check that we only found one match if len(matches) != 1: if len(matches) == 0: raise IOError( "Kernel file '{0}.[fF]90' not found in {1}". format(modulename, cdir)) else: raise IOError( "More than one match for kernel file " "'{0}.[fF]90' found!".format(modulename)) else: try: modast = fpapi.parse(matches[0]) # ast includes an extra comment line which # contains file details. This line can be # long which can cause line length # issues. Therefore set the information # (name) to be empty. modast.name = "" except: raise ParseError( "Failed to parse kernel code " "'{0}'. Is the Fortran correct?".format( matches[0])) if line_length: fll = FortLineLength() with open(matches[0], "r") as myfile: code_str = myfile.read() if fll.long_lines(code_str): raise ParseError( "parse: the kernel file '{0}' does not" " conform to the specified {1} line length" " limit".format(modulename, str(fll.length))) statement_kcalls.append( KernelCall( modulename, KernelTypeFactory(api=api).create(modast, name=argname), argargs)) invokecalls[statement] = InvokeCall(statement_kcalls, name=invoke_label) return ast, FileInfo(container_name, invokecalls)
def main(args): ''' Parses and checks the command line arguments, calls the generate function if all is well, catches any errors and outputs the results. :param list args: the list of command-line arguments that PSyclone has \ been invoked with. ''' # pylint: disable=too-many-statements,too-many-branches # Make sure we have the supported APIs defined in the Config singleton, # but postpone loading the config file till the command line was parsed # in case that the user specifies a different config file. Config.get(do_not_load_file=True) parser = argparse.ArgumentParser( description='Run the PSyclone code generator on a particular file') parser.add_argument('-oalg', help='filename of transformed algorithm code') parser.add_argument('-opsy', help='filename of generated PSy code') parser.add_argument('-okern', help='directory in which to put transformed kernels, ' 'default is the current working directory.') parser.add_argument('-api', help='choose a particular api from {0}, ' 'default \'{1}\'.'.format( str(Config.get().supported_apis), Config.get().default_api)) parser.add_argument('filename', help='algorithm-layer source code') parser.add_argument('-s', '--script', help='filename of a PSyclone' ' optimisation script') parser.add_argument('-d', '--directory', default="", help='path to root of directory ' 'structure containing kernel source code') # Make the default an empty list so that we can check whether the # user has supplied a value(s) later parser.add_argument('-I', '--include', default=[], action="append", help='path to Fortran INCLUDE files (nemo API only)') parser.add_argument('-l', '--limit', dest='limit', action='store_true', default=False, help='limit the fortran line length to 132 characters') parser.add_argument('-dm', '--dist_mem', dest='dist_mem', action='store_true', help='generate distributed memory code') parser.add_argument('-nodm', '--no_dist_mem', dest='dist_mem', action='store_false', help='do not generate distributed memory code') parser.add_argument( '--kernel-renaming', default="multiple", choices=configuration.VALID_KERNEL_NAMING_SCHEMES, help="Naming scheme to use when re-naming transformed kernels") parser.add_argument( '--profile', '-p', action="append", choices=Profiler.SUPPORTED_OPTIONS, help="Add profiling hooks for either 'kernels' or 'invokes'") parser.add_argument( '--force-profile', action="append", choices=Profiler.SUPPORTED_OPTIONS, help="Add profiling hooks for either 'kernels' or 'invokes' even if a " "transformation script is used. Use at your own risk.") parser.set_defaults(dist_mem=Config.get().distributed_memory) parser.add_argument("--config", help="Config file with " "PSyclone specific options.") parser.add_argument( '-v', '--version', dest='version', action="store_true", help='Display version information ({0})'.format(__VERSION__)) args = parser.parse_args(args) if args.version: print("PSyclone version: {0}".format(__VERSION__)) if args.script is not None and args.profile is not None: print( "Error: use of automatic profiling in combination with an\n" "optimisation script is not recommended since it may not work\n" "as expected.\n" "You can use --force-profile instead of --profile if you \n" "really want to use both options at the same time.", file=sys.stderr) exit(1) if args.profile is not None and args.force_profile is not None: print("Specify only one of --profile and --force-profile.", file=sys.stderr) exit(1) if args.profile: Profiler.set_options(args.profile) elif args.force_profile: Profiler.set_options(args.force_profile) # If an output directory has been specified for transformed kernels # then check that it is valid if args.okern: if not os.path.exists(args.okern): print("Specified kernel output directory ({0}) does not exist.". format(args.okern), file=sys.stderr) exit(1) if not os.access(args.okern, os.W_OK): print("Cannot write to specified kernel output directory ({0}).". format(args.okern), file=sys.stderr) exit(1) kern_out_path = args.okern else: # We write any transformed kernels to the current working directory kern_out_path = os.getcwd() # If no config file name is specified, args.config is none # and config will load the default config file. Config.get().load(args.config) # Check API, if none is specified, take the setting from the config file if args.api is None: # No command line option, use the one specified in Config - which # is either based on a parameter in the config file, or otherwise # the default: api = Config.get().api elif args.api not in Config.get().supported_apis: print("Unsupported API '{0}' specified. Supported API's are " "{1}.".format(args.api, Config.get().supported_apis), file=sys.stderr) exit(1) else: # There is a valid API specified on the command line. Set it # as API in the config object as well. api = args.api Config.get().api = api # Store the search path(s) for include files if args.include and api != 'nemo': # We only support passing include paths to fparser2 and it's # only the NEMO API that uses fparser2 currently. print( "Setting the search path for Fortran include files " "(-I/--include) is only supported for the 'nemo' API.", file=sys.stderr) exit(1) # The Configuration manager checks that the supplied path(s) is/are # valid so protect with a try try: if args.include: Config.get().include_paths = args.include else: # Default is to instruct fparser2 to look in the directory # containing the file being parsed Config.get().include_paths = ["./"] except ConfigurationError as err: print(str(err), file=sys.stderr) exit(1) try: alg, psy = generate(args.filename, api=api, kernel_path=args.directory, script_name=args.script, line_length=args.limit, distributed_memory=args.dist_mem, kern_out_path=kern_out_path, kern_naming=args.kernel_renaming) except NoInvokesError: _, exc_value, _ = sys.exc_info() print("Warning: {0}".format(exc_value)) # no invoke calls were found in the algorithm file so we need # not need to process it, or generate any psy layer code so # output the original algorithm file and set the psy file to # be empty alg_file = open(args.filename) alg = alg_file.read() psy = "" except (OSError, IOError, ParseError, GenerationError, RuntimeError): _, exc_value, _ = sys.exc_info() print(exc_value, file=sys.stderr) exit(1) except Exception: # pylint: disable=broad-except print("Error, unexpected exception, please report to the authors:", file=sys.stderr) exc_type, exc_value, exc_tb = sys.exc_info() print("Description ...", file=sys.stderr) print(exc_value, file=sys.stderr) print("Type ...", file=sys.stderr) print(exc_type, file=sys.stderr) print("Stacktrace ...", file=sys.stderr) traceback.print_tb(exc_tb, limit=20, file=sys.stderr) exit(1) if args.limit: fll = FortLineLength() psy_str = fll.process(str(psy)) alg_str = fll.process(str(alg)) else: psy_str = str(psy) alg_str = str(alg) if args.oalg is not None: my_file = open(args.oalg, "w") my_file.write(alg_str) my_file.close() else: print("Transformed algorithm code:\n%s" % alg_str) if not psy_str: # empty file so do not output anything pass elif args.opsy is not None: my_file = open(args.opsy, "w") my_file.write(psy_str) my_file.close() else: print("Generated psy layer code:\n", psy_str)
def main(args): ''' Parses and checks the command line arguments, calls the generate function if all is well, catches any errors and outputs the results ''' # pylint: disable=too-many-statements parser = argparse.ArgumentParser( description='Run the PSyclone code generator on a particular file') parser.add_argument('-oalg', help='filename of transformed algorithm code') parser.add_argument('-opsy', help='filename of generated PSy code') parser.add_argument('-api', default=DEFAULTAPI, help='choose a particular api from {0}, ' 'default {1}'.format(str(SUPPORTEDAPIS), DEFAULTAPI)) parser.add_argument('filename', help='algorithm-layer source code') parser.add_argument('-s', '--script', help='filename of a PSyclone' ' optimisation script') parser.add_argument('-d', '--directory', default="", help='path to root of directory ' 'structure containing kernel source code') parser.add_argument('-l', '--limit', dest='limit', action='store_true', default=False, help='limit the fortran line length to 132 characters') parser.add_argument('-dm', '--dist_mem', dest='dist_mem', action='store_true', help='generate distributed memory code') parser.add_argument('-nodm', '--no_dist_mem', dest='dist_mem', action='store_false', help='do not generate distributed memory code') parser.set_defaults(dist_mem=DISTRIBUTED_MEMORY) parser.add_argument( '-v', '--version', dest='version', action="store_true", help='Display version information ({0})'.format(__VERSION__)) args = parser.parse_args(args) if args.api not in SUPPORTEDAPIS: print "Unsupported API '{0}' specified. Supported API's are "\ "{1}.".format(args.api, SUPPORTEDAPIS) exit(1) if args.version: print "PSyclone version: {0}".format(__VERSION__) # pylint: disable=broad-except try: alg, psy = generate(args.filename, api=args.api, kernel_path=args.directory, script_name=args.script, line_length=args.limit, distributed_memory=args.dist_mem) except NoInvokesError: _, exc_value, _ = sys.exc_info() print "Warning: {0}".format(exc_value) # no invoke calls were found in the algorithm file so we need # not need to process it, or generate any psy layer code so # output the original algorithm file and set the psy file to # be empty alg_file = open(args.filename) alg = alg_file.read() psy = "" except (OSError, IOError, ParseError, GenerationError, RuntimeError): _, exc_value, _ = sys.exc_info() print exc_value exit(1) except Exception: print "Error, unexpected exception, please report to the authors:" exc_type, exc_value, exc_tb = sys.exc_info() print "Description ..." print exc_value print "Type ..." print exc_type print "Stacktrace ..." traceback.print_tb(exc_tb, limit=10, file=sys.stdout) exit(1) if args.limit: fll = FortLineLength() psy_str = fll.process(str(psy)) alg_str = fll.process(str(alg)) else: psy_str = str(psy) alg_str = str(alg) if args.oalg is not None: my_file = open(args.oalg, "w") my_file.write(alg_str) my_file.close() else: print "Transformed algorithm code:\n", alg_str if not psy_str: # empty file so do not output anything pass elif args.opsy is not None: my_file = open(args.opsy, "w") my_file.write(psy_str) my_file.close() else: print "Generated psy layer code:\n", psy_str