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) == []
