def test_kernelschedule_constructor(): ''' Check that we can construct a KernelSchedule and that it has the expected properties. ''' ksched = KernelSchedule("timetable") assert ksched.name == "timetable" # A KernelSchedule does not represent a program assert not ksched.is_program # A KernelSchedule does not return anything assert ksched.return_type is None assert ksched.parent is None # Now create a KernelSchedule with a parent cnode = Container("BigBox") ksched2 = KernelSchedule("plan", parent=cnode) assert ksched2.parent is cnode
def test_scope(): '''Test that the scope method in a Node instance returns the closest ancestor Schedule or Container Node (including itself) or raises an exception if one does not exist. ''' kernel_symbol_table = SymbolTable() symbol = DataSymbol("tmp", REAL_TYPE) kernel_symbol_table.add(symbol) ref = Reference(symbol) assign = Assignment.create(ref, Literal("0.0", REAL_TYPE)) kernel_schedule = KernelSchedule.create("my_kernel", kernel_symbol_table, [assign]) container = Container.create("my_container", SymbolTable(), [kernel_schedule]) assert ref.scope is kernel_schedule assert assign.scope is kernel_schedule assert kernel_schedule.scope is kernel_schedule assert container.scope is container anode = Literal("x", INTEGER_TYPE) with pytest.raises(SymbolError) as excinfo: _ = anode.scope assert ("Unable to find the scope of node " "'Literal[value:'x', Scalar<INTEGER, UNDEFINED>]' as " "none of its ancestors are Container or Schedule nodes." in str(excinfo.value))
def test_use_stmt(): ''' Check that SymbolTable entries are correctly created from module use statements. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() reader = FortranStringReader("use my_mod, only: some_var\n" "use this_mod\n" "use other_mod, only: var1, var2\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) symtab = fake_parent.symbol_table for module_name in ["my_mod", "this_mod", "other_mod"]: container = symtab.lookup(module_name) assert isinstance(container, ContainerSymbol) assert container.name == module_name # Container reference is not updated until explicitly requested assert not container._reference for var in ["some_var", "var1", "var2"]: assert symtab.lookup(var).name == var assert symtab.lookup("some_var").interface.container_symbol \ == symtab.lookup("my_mod") assert symtab.lookup("var2").interface.container_symbol \ == symtab.lookup("other_mod")
def test_multi_use_stmt(): ''' Check that we handle the case where different symbols are imported from a module in separate USE statements. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() reader = FortranStringReader("use my_mod, only: some_var\n" "use this_mod\n" "use my_mod, only: var1, var2\n" "use this_mod, only: var3\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) symtab = fake_parent.symbol_table csymbols = symtab.containersymbols # Although there are 4 use statements, there are only 2 modules assert len(csymbols) == 2 my_mod = symtab.lookup("my_mod") assert not my_mod.wildcard_import # Check that we have accumulated all imports import_list = symtab.imported_symbols(my_mod) assert len(import_list) == 3 names = [sym.name for sym in import_list] assert sorted(names) == ["some_var", "var1", "var2"] this_mod = symtab.lookup("this_mod") assert this_mod.wildcard_import names = [sym.name for sym in symtab.imported_symbols(this_mod)] assert names == ["var3"]
def test_redundant_empty_only_list(): ''' Check that we drop 'use's with an empty only list if they become redundant. #TODO #11 Check for appropriate logging messages here once logging is implemented. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() # Empty only-list followed by wildcard import reader = FortranStringReader("use mod1, only:\n" "use mod1\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) csym = fake_parent.symbol_table.lookup("mod1") assert csym.wildcard_import # Wildcard import followed by empty only-list reader = FortranStringReader("use mod2\n" "use mod2, only:\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) csym = fake_parent.symbol_table.lookup("mod2") assert csym.wildcard_import # Empty only-list followed by named import reader = FortranStringReader("use mod3, only:\n" "use mod3, only: fred\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) sym_table = fake_parent.symbol_table csym = sym_table.lookup("mod3") assert not csym.wildcard_import assert sym_table.imported_symbols(csym)[0].name == "fred" # Named import followed by empty only-list reader = FortranStringReader("use mod4, only: bob\n" "use mod4, only:\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) csym = sym_table.lookup("mod4") assert not csym.wildcard_import assert sym_table.imported_symbols(csym)[0].name == "bob"
def test_transform_apply_insert(tmpdir): '''Check that the PSyIR is transformed as expected when there are multiple statements in the PSyIR. The resultant Fortran code is used to confirm the transformation has worked correctly. ''' trans = ArrayRange2LoopTrans() symbol_table = SymbolTable() symbol = DataSymbol("n", INTEGER_TYPE) symbol_table.add(symbol) # Create the first assignment. In Fortran notation: x(:) = y(n,:) lhs = create_array_x(symbol_table) rhs = create_array_y(symbol_table) assignment1 = Assignment.create(lhs, rhs) # Create the second assignment. In Fortran notation: y2(:,:) = z(:,n,:) lhs = create_array_y_2d_slice(symbol_table) rhs = create_array_z(symbol_table) assignment2 = Assignment.create(lhs, rhs) routine = KernelSchedule.create("work", symbol_table, [assignment1, assignment2]) trans.apply(assignment1) trans.apply(assignment2) writer = FortranWriter() expected = (" do idx = LBOUND(x, 1), UBOUND(x, 1), 1\n" " x(idx)=y(n,idx)\n" " enddo\n" " do idx_1 = LBOUND(y2, 2), UBOUND(y2, 2), 1\n" " y2(:,idx_1)=z(:,n,idx_1)\n" " enddo\n") result = writer(routine) assert expected in result assert Compile(tmpdir).string_compiles(result)
def test_lower_to_lang_level_single_node(): ''' Test the lower_to_language_level() method when a Schedule contains a single ProfileNode. ''' Profiler.set_options([Profiler.INVOKES]) symbol_table = SymbolTable() arg1 = symbol_table.new_symbol(symbol_type=DataSymbol, datatype=REAL_TYPE) zero = Literal("0.0", REAL_TYPE) one = Literal("1.0", REAL_TYPE) assign1 = Assignment.create(Reference(arg1), zero) assign2 = Assignment.create(Reference(arg1), one) kschedule = KernelSchedule.create( "work1", symbol_table, [assign1, assign2, Return()]) Profiler.add_profile_nodes(kschedule, Loop) assert isinstance(kschedule.children[0], ProfileNode) assert isinstance(kschedule.children[-1], Return) kschedule.lower_to_language_level() # The ProfileNode should have been replaced by two CodeBlocks with its # children inserted between them. assert isinstance(kschedule[0], CodeBlock) # The first CodeBlock should have the "profile-start" annotation. assert kschedule[0].annotations == ["profile-start"] ptree = kschedule[0].get_ast_nodes assert len(ptree) == 1 assert isinstance(ptree[0], Fortran2003.Call_Stmt) assert kschedule[1] is assign1 assert kschedule[2] is assign2 assert isinstance(kschedule[-2], CodeBlock) assert kschedule[-2].annotations == [] ptree = kschedule[-2].get_ast_nodes assert len(ptree) == 1 assert isinstance(ptree[0], Fortran2003.Call_Stmt) assert isinstance(kschedule[-1], Return)
def test_find_or_create_imported_symbol_2(): ''' Check that the _find_or_create_imported_symbol() method creates new symbols when appropriate. ''' # Create some suitable PSyIR from scratch symbol_table = SymbolTable() symbol_table.add(DataSymbol("tmp", REAL_TYPE)) kernel1 = KernelSchedule.create("mod_1", SymbolTable(), []) container = Container.create("container_name", symbol_table, [kernel1]) xvar = DataSymbol("x", REAL_TYPE) xref = Reference(xvar) assign = Assignment.create(xref, Literal("1.0", REAL_TYPE)) kernel1.addchild(assign) # We have no wildcard imports so there can be no symbol named 'undefined' with pytest.raises(SymbolError) as err: _ = _find_or_create_imported_symbol(assign, "undefined") assert "No Symbol found for name 'undefined'" in str(err.value) # We should be able to find the 'tmp' symbol in the parent Container sym = _find_or_create_imported_symbol(assign, "tmp") assert sym.datatype.intrinsic == ScalarType.Intrinsic.REAL # Add a wildcard import to the SymbolTable of the KernelSchedule new_container = ContainerSymbol("some_mod") new_container.wildcard_import = True kernel1.symbol_table.add(new_container) # Symbol not in any container but we do have wildcard imports so we # get a new symbol back new_symbol = _find_or_create_imported_symbol(assign, "undefined") assert new_symbol.name == "undefined" assert isinstance(new_symbol.interface, UnresolvedInterface) # pylint: disable=unidiomatic-typecheck assert type(new_symbol) == Symbol assert "undefined" not in container.symbol_table assert kernel1.symbol_table.lookup("undefined") is new_symbol
def example_psyir_nary(): '''Utility function that creates a PSyIR tree containing a nary MIN intrinsic operator and returns the operator. :returns: PSyIR MIN operator instance. :rtype: :py:class:`psyclone.psyGen.NaryOperation` ''' symbol_table = SymbolTable() arg1 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) arg2 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) arg3 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) arg4 = symbol_table.new_symbol(symbol_type=DataSymbol, datatype=REAL_TYPE) symbol_table.specify_argument_list([arg1, arg2, arg3]) var1 = Reference(arg1) var2 = Reference(arg2) var3 = Reference(arg3) var4 = Reference(arg4) oper = NaryOperation.Operator.MIN operation = NaryOperation.create(oper, [var1, var2, var3]) assign = Assignment.create(var4, operation) _ = KernelSchedule.create("min_example", symbol_table, [assign]) return operation
def test_find_or_create_change_symbol_type(): ''' Check that the _find_or_create_imported_symbol routine correctly updates the class of the located symbol if it is not an instance of the requested symbol type. ''' # pylint: disable=unidiomatic-typecheck # Create some suitable PSyIR from scratch symbol_table = SymbolTable() tmp_sym = symbol_table.new_symbol("tmp") sub_sym = symbol_table.new_symbol("my_sub") kernel1 = KernelSchedule.create("mod_1", SymbolTable(), []) _ = Container.create("container_name", symbol_table, [kernel1]) assign = Assignment.create(Reference(tmp_sym), Literal("1.0", REAL_TYPE)) kernel1.addchild(assign) # Search for the 'tmp' symbol sym = _find_or_create_imported_symbol(assign, "tmp") assert sym is tmp_sym assert type(sym) == Symbol # Repeat but this time specify that we're expecting a DataSymbol sym = _find_or_create_imported_symbol(assign, "tmp", symbol_type=DataSymbol, datatype=REAL_TYPE) assert sym is tmp_sym assert type(sym) == DataSymbol assert sym.datatype == REAL_TYPE # Search for 'my_sub' and specify that it should be a RoutineSymbol sym2 = _find_or_create_imported_symbol(assign, "my_sub", symbol_type=RoutineSymbol) assert sym2 is sub_sym assert type(sym2) == RoutineSymbol
def example_psyir_binary(create_expression): '''Utility function that creates a PSyIR tree containing a binary MIN intrinsic operator and returns the operator. :param function create_expresssion: function used to create the \ content of the first argument of the MIN operator. :returns: PSyIR MIN operator instance. :rtype: :py:class:`psyclone.psyGen.BinaryOperation` ''' symbol_table = SymbolTable() arg1 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) arg2 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) arg3 = symbol_table.new_symbol(symbol_type=DataSymbol, datatype=REAL_TYPE) symbol_table.specify_argument_list([arg1, arg2]) var1 = Reference(arg1) var2 = Reference(arg2) var3 = Reference(arg3) oper = BinaryOperation.Operator.MIN operation = BinaryOperation.create(oper, create_expression(var1), var2) assign = Assignment.create(var3, operation) _ = KernelSchedule.create("min_example", symbol_table, [assign]) return operation
def test_profile_node_create(): ''' Basic checks for the create() method of ProfileNode. ''' sched = KernelSchedule.create("test", SymbolTable(), []) pnode = ProfileNode.create([], SymbolTable()) sched.addchild(pnode) assert str(pnode) == ("ProfileStart[var=profile_psy_data]\n" "ProfileEnd") pnode2 = ProfileNode.create([], symbol_table=sched.symbol_table, options={"region_name": ("my_mod", "first")}) assert pnode2._module_name == "my_mod" assert pnode2._region_name == "first" # Check that the symbol table contains the appropriate symbols: # A Container for the profile_psy_data_mod module table = sched.symbol_table csym = table.lookup("profile_psy_data_mod") assert isinstance(csym, ContainerSymbol) # A type symbol for the derived type used to capture profiling data type_sym = table.lookup("profile_PSyDataType") assert isinstance(type_sym, TypeSymbol) assert isinstance(type_sym.interface, GlobalInterface) assert type_sym.interface.container_symbol is csym # A symbol of derived type to contain the profiling data. As it must # have the (unsupported) 'save' and 'target' attributes, it has to be of # UnknownFortranType. dsym = table.lookup("profile_psy_data") assert isinstance(dsym, DataSymbol) assert isinstance(dsym.datatype, UnknownFortranType) assert (dsym.datatype.declaration == "type(profile_PSyDataType), save, target :: profile_psy_data")
def example_psyir(create_expression): '''Utility function that creates a PSyIR tree containing an ABS intrinsic operator and returns the operator. :param function create_expresssion: function used to create the \ content of the ABS operator. :returns: PSyIR ABS operator instance. :rtype: :py:class:`psyclone.psyGen.UnaryOperation` ''' symbol_table = SymbolTable() arg1 = symbol_table.new_symbol("arg", symbol_type=DataSymbol, datatype=REAL_TYPE, interface=ArgumentInterface( ArgumentInterface.Access.READWRITE)) local = symbol_table.new_symbol(symbol_type=DataSymbol, datatype=REAL_TYPE) symbol_table.specify_argument_list([arg1]) var1 = Reference(arg1) var2 = Reference(local) oper = UnaryOperation.Operator.ABS operation = UnaryOperation.create(oper, create_expression(var1)) assign = Assignment.create(var2, operation) _ = KernelSchedule.create("abs_example", symbol_table, [assign]) return operation
def test_transform_multi_apply(tmpdir): '''Check that the ArrayRange2Loop transformation can be used to create nested loops by calling it multiple times when an array has multiple dimensions that use a range. ''' trans = ArrayRange2LoopTrans() symbol_table = SymbolTable() symbol = DataSymbol("n", INTEGER_TYPE) symbol_table.add(symbol) lhs = create_array_y_2d_slice(symbol_table) rhs = create_array_z(symbol_table) assignment = Assignment.create(lhs, rhs) routine = KernelSchedule.create("work", symbol_table, [assignment]) trans.apply(assignment) trans.apply(assignment) expected = (" do idx = LBOUND(y2, 2), UBOUND(y2, 2), 1\n" " do idx_1 = LBOUND(y2, 1), UBOUND(y2, 1), 1\n" " y2(idx_1,idx)=z(idx_1,n,idx)\n" " enddo\n" " enddo\n") writer = FortranWriter() result = writer(routine) assert expected in result assert Compile(tmpdir).string_compiles(result)
def test_parse_derived_type(use_stmt, type_name): ''' Check that the fronted correctly creates a DataTypeSymbol of type StructureType from the declaration of a derived type. ''' fake_parent = KernelSchedule("dummy_schedule") symtab = fake_parent.symbol_table processor = Fparser2Reader() reader = FortranStringReader("{0}\n" "type :: my_type\n" " integer :: flag\n" " type({1}), private :: grid\n" " real, dimension(3) :: posn\n" "end type my_type\n" "type(my_type) :: var\n".format( use_stmt, type_name)) fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) sym = symtab.lookup("my_type") assert isinstance(sym, DataTypeSymbol) assert isinstance(sym.datatype, StructureType) flag = sym.datatype.lookup("flag") assert isinstance(flag.datatype, ScalarType) assert flag.visibility == Symbol.Visibility.PUBLIC grid = sym.datatype.lookup("grid") assert isinstance(grid.datatype, DataTypeSymbol) assert isinstance(grid.datatype.datatype, DeferredType) assert grid.visibility == Symbol.Visibility.PRIVATE posn = sym.datatype.lookup("posn") assert isinstance(posn.datatype, ArrayType) var = symtab.lookup("var") assert var.datatype is sym
def test_container_create_invalid(): '''Test that the create method in a Container class raises the expected exception if the provided input is invalid. ''' symbol_table = SymbolTable() symbol_table.add(DataSymbol("x", REAL_SINGLE_TYPE)) children = [KernelSchedule.create("mod_1", SymbolTable(), [])] # name is not a string. with pytest.raises(GenerationError) as excinfo: _ = Container.create(1, symbol_table, children) assert ("name argument in create method of Container class " "should be a string but found 'int'.") in str(excinfo.value) # symbol_table not a SymbolTable. with pytest.raises(GenerationError) as excinfo: _ = Container.create("container", "invalid", children) assert ("symbol_table argument in create method of Container class " "should be a SymbolTable but found 'str'.") in str(excinfo.value) # children not a list. with pytest.raises(GenerationError) as excinfo: _ = Container.create("mod_name", symbol_table, "invalid") assert ("children argument in create method of Container class should " "be a list but found 'str'." in str(excinfo.value)) # contents of children list are not Container or KernelSchedule. with pytest.raises(GenerationError) as excinfo: _ = Container.create("mod_name", symbol_table, ["invalid"]) assert ("Item 'str' can't be child 0 of 'Container'. The valid format is:" " '[Container | KernelSchedule | InvokeSchedule]*'." in str(excinfo.value))
def test_range_references_props(): ''' Test that the properties of a Range return what we expect when the start, stop and step are references or expressions. ''' from psyclone.psyir.nodes import BinaryOperation, KernelSchedule sched = KernelSchedule("test_sched") sym_table = sched.symbol_table start_symbol = DataSymbol("istart", INTEGER_SINGLE_TYPE) stop_symbol = DataSymbol("istop", INTEGER_SINGLE_TYPE) step_symbol = DataSymbol("istep", INTEGER_SINGLE_TYPE) sym_table.add(start_symbol) sym_table.add(stop_symbol) sym_table.add(step_symbol) startvar = Reference(start_symbol) stopvar = Reference(stop_symbol) start = BinaryOperation.create(BinaryOperation.Operator.SUB, startvar, Literal("1", INTEGER_SINGLE_TYPE)) stop = BinaryOperation.create(BinaryOperation.Operator.ADD, stopvar, Literal("1", INTEGER_SINGLE_TYPE)) step = Reference(step_symbol) erange = Range.create(start, stop, step) assert erange.start is start assert erange.stop is stop assert erange.step is step assert erange.children[0] is start assert erange.children[1] is stop assert erange.children[2] is step
def test_get_external_symbol(monkeypatch): ''' Test the get_external_symbol() method. ''' asym = Symbol("a") with pytest.raises(NotImplementedError) as err: asym.get_external_symbol() assert ("trying to resolve symbol 'a' properties, the lazy evaluation " "of 'Local' interfaces is not supported" in str(err.value)) other_container = ContainerSymbol("some_mod") ctable = SymbolTable() ctable.add(other_container) # Create a Symbol that is imported from the "some_mod" Container bsym = Symbol("b", interface=GlobalInterface(other_container)) ctable.add(bsym) _ = Container.create("test", ctable, [KernelSchedule("dummy")]) # Monkeypatch the container's FortranModuleInterface so that it always # appears to be unable to find the "some_mod" module def fake_import(name): raise SymbolError("Oh dear") monkeypatch.setattr(other_container._interface, "import_container", fake_import) with pytest.raises(SymbolError) as err: bsym.get_external_symbol() assert ("trying to resolve the properties of symbol 'b' in module " "'some_mod': PSyclone SymbolTable error: Oh dear" in str(err.value)) # Now create a Container for the 'some_mod' module and attach this to # the ContainerSymbol ctable2 = SymbolTable() some_mod = Container.create("some_mod", ctable2, [KernelSchedule("dummy2")]) other_container._reference = some_mod # Currently the Container does not contain an entry for 'b' with pytest.raises(SymbolError) as err: bsym.get_external_symbol() assert ("trying to resolve the properties of symbol 'b'. The interface " "points to module 'some_mod' but could not find the definition" in str(err.value)) # Add an entry for 'b' to the Container's symbol table ctable2.add(DataSymbol("b", INTEGER_SINGLE_TYPE)) new_sym = bsym.resolve_deferred() assert isinstance(new_sym, DataSymbol) assert new_sym.datatype == INTEGER_SINGLE_TYPE
def create_matmul(): '''Utility function that creates a valid matmul node for use with subsequent tests. ''' symbol_table = SymbolTable() one = Literal("1", INTEGER_TYPE) two = Literal("2", INTEGER_TYPE) index = DataSymbol("idx", INTEGER_TYPE, constant_value=3) symbol_table.add(index) array_type = ArrayType(REAL_TYPE, [5, 10, 15]) mat_symbol = DataSymbol("x", array_type) symbol_table.add(mat_symbol) lbound1 = BinaryOperation.create(BinaryOperation.Operator.LBOUND, Reference(mat_symbol), one.copy()) ubound1 = BinaryOperation.create(BinaryOperation.Operator.UBOUND, Reference(mat_symbol), one.copy()) my_mat_range1 = Range.create(lbound1, ubound1, one.copy()) lbound2 = BinaryOperation.create(BinaryOperation.Operator.LBOUND, Reference(mat_symbol), two.copy()) ubound2 = BinaryOperation.create(BinaryOperation.Operator.UBOUND, Reference(mat_symbol), two.copy()) my_mat_range2 = Range.create(lbound2, ubound2, one.copy()) matrix = ArrayReference.create( mat_symbol, [my_mat_range1, my_mat_range2, Reference(index)]) array_type = ArrayType(REAL_TYPE, [10, 20]) vec_symbol = DataSymbol("y", array_type) symbol_table.add(vec_symbol) lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND, Reference(vec_symbol), one.copy()) ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND, Reference(vec_symbol), one.copy()) my_vec_range = Range.create(lbound, ubound, one.copy()) vector = ArrayReference.create( vec_symbol, [my_vec_range, Reference(index)]) matmul = BinaryOperation.create(BinaryOperation.Operator.MATMUL, matrix, vector) lhs_type = ArrayType(REAL_TYPE, [10]) lhs_symbol = DataSymbol("result", lhs_type) symbol_table.add(lhs_symbol) lhs = Reference(lhs_symbol) assign = Assignment.create(lhs, matmul) KernelSchedule.create("my_kern", symbol_table, [assign]) return matmul
def test_array_node_str(): ''' Check the node_str method of the ArrayReference class.''' kschedule = KernelSchedule("kname") array_type = ArrayType(INTEGER_SINGLE_TYPE, [ArrayType.Extent.ATTRIBUTE]) symbol = DataSymbol("aname", array_type) kschedule.symbol_table.add(symbol) array = ArrayReference(symbol) coloredtext = colored("ArrayReference", ArrayReference._colour) assert coloredtext + "[name:'aname']" in array.node_str()
def test_reference_can_be_printed(): '''Test that a Reference instance can always be printed (i.e. is initialised fully)''' kschedule = KernelSchedule("kname") symbol = DataSymbol("rname", INTEGER_SINGLE_TYPE) kschedule.symbol_table.add(symbol) assignment = Assignment(parent=kschedule) ref = Reference(symbol, assignment) assert "Reference[name:'rname']" in str(ref)
def test_array_can_be_printed(): '''Test that an Array instance can always be printed (i.e. is initialised fully)''' kschedule = KernelSchedule("kname") symbol = DataSymbol("aname", INTEGER_SINGLE_TYPE) kschedule.symbol_table.add(symbol) assignment = Assignment(parent=kschedule) array = Array(symbol, assignment) assert "ArrayReference[name:'aname']\n" in str(array)
def test_reference_node_str(): ''' Check the node_str method of the Reference class.''' kschedule = KernelSchedule("kname") symbol = DataSymbol("rname", INTEGER_SINGLE_TYPE) kschedule.symbol_table.add(symbol) assignment = Assignment(parent=kschedule) ref = Reference(symbol, assignment) coloredtext = colored("Reference", Reference._colour) assert coloredtext + "[name:'rname']" in ref.node_str()
def test_reference_node_str(): ''' Check the node_str method of the Reference class.''' from psyclone.psyir.nodes.node import colored, SCHEDULE_COLOUR_MAP kschedule = KernelSchedule("kname") symbol = DataSymbol("rname", INTEGER_SINGLE_TYPE) kschedule.symbol_table.add(symbol) assignment = Assignment(parent=kschedule) ref = Reference(symbol, assignment) coloredtext = colored("Reference", SCHEDULE_COLOUR_MAP["Reference"]) assert coloredtext + "[name:'rname']" in ref.node_str()
def test_auto_invoke_no_return(capsys): ''' Check that using the auto-invoke profiling option does not add any profiling if the invoke contains a Return anywhere other than as the last statement. ''' Profiler.set_options([Profiler.INVOKES]) symbol_table = SymbolTable() arg1 = symbol_table.new_symbol( symbol_type=DataSymbol, datatype=REAL_TYPE) zero = Literal("0.0", REAL_TYPE) assign1 = Assignment.create(Reference(arg1), zero) assign2 = Assignment.create(Reference(arg1), zero.copy()) # Create Schedule with Return at the start. kschedule = KernelSchedule.create( "work1", symbol_table, [Return(), assign1, assign2]) Profiler.add_profile_nodes(kschedule, Loop) # No profiling should have been added assert not kschedule.walk(ProfileNode) _, err = capsys.readouterr() assert ("Not adding profiling to routine 'work1' because it contains one " "or more Return statements" in err) # Create Schedule with Return in the middle. kschedule = KernelSchedule.create( "work2", symbol_table, [assign1.copy(), Return(), assign2.copy()]) Profiler.add_profile_nodes(kschedule, Loop) # No profiling should have been added assert not kschedule.walk(ProfileNode) _, err = capsys.readouterr() assert ("Not adding profiling to routine 'work2' because it contains one " "or more Return statements" in err) # Create Schedule with a Return at the end as well as in the middle. kschedule = KernelSchedule.create( "work3", symbol_table, [assign1.copy(), Return(), assign2.copy(), Return()]) Profiler.add_profile_nodes(kschedule, Loop) # No profiling should have been added assert not kschedule.walk(ProfileNode) _, err = capsys.readouterr() assert ("Not adding profiling to routine 'work3' because it contains one " "or more Return statements" in err)
def test_array_node_str(): ''' Check the node_str method of the Array class.''' from psyclone.psyir.nodes.node import colored, SCHEDULE_COLOUR_MAP kschedule = KernelSchedule("kname") array_type = ArrayType(INTEGER_SINGLE_TYPE, [ArrayType.Extent.ATTRIBUTE]) symbol = DataSymbol("aname", array_type) kschedule.symbol_table.add(symbol) assignment = Assignment(parent=kschedule) array = Array(symbol, parent=assignment) coloredtext = colored("ArrayReference", SCHEDULE_COLOUR_MAP["Reference"]) assert coloredtext + "[name:'aname']" in array.node_str()
def test_name_clash_use_stmt(): ''' Check that we raise the expected error if we encounter a module with a name that's already taken in the Symbol Table. This is invalid Fortran but we need to test the error-handling in PSyclone. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() reader = FortranStringReader("use my_mod, only: some_var\n" "use some_var, only: var1, var2\n") fparser2spec = Fortran2003.Specification_Part(reader) with pytest.raises(SymbolError) as err: processor.process_declarations(fake_parent, fparser2spec.content, []) assert "Found a USE of module 'some_var' but the symbol" in str(err.value)
def test_missing_derived_type(): ''' Check that the fronted raises an error if it encounters a variable of a derived type that cannot be resolved. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() reader = FortranStringReader("type(my_type) :: var") fparser2spec = Fortran2003.Specification_Part(reader) # This should raise an error because there's no Container from which # the definition of 'my_type' can be brought into scope. with pytest.raises(SymbolError) as err: processor.process_declarations(fake_parent, fparser2spec.content, []) assert "No Symbol found for name 'my_type'" in str(err.value)
def test_arraytype_shape_dim_from_parent_scope(): ''' Check that the shape checking in the ArrayType class permits the use of a reference to a symbol in a parent scope. ''' cont = Container("test_mod") dim_sym = cont.symbol_table.new_symbol("dim1", symbol_type=DataSymbol, datatype=INTEGER_TYPE) kernel1 = KernelSchedule.create("mod_1", SymbolTable(), []) cont.addchild(kernel1) asym = kernel1.symbol_table.new_symbol( "array1", symbol_type=DataSymbol, datatype=ArrayType(INTEGER_TYPE, [Reference(dim_sym)])) assert isinstance(asym, DataSymbol)
def test_use_no_only_list(): ''' Check that we create the correct Symbol Table entry for a use statement that has an 'only' clause but no list of imported symbols. ''' fake_parent = KernelSchedule("dummy_schedule") processor = Fparser2Reader() reader = FortranStringReader("use my_mod, only: some_var\n" "use some_mod, only:\n") fparser2spec = Fortran2003.Specification_Part(reader) processor.process_declarations(fake_parent, fparser2spec.content, []) some_mod = fake_parent.symbol_table.lookup("some_mod") assert not some_mod.wildcard_import assert fake_parent.symbol_table.imported_symbols(some_mod) == []