def test_halo_read_access_is_abstract():
'''Check that the generic _halo_read_access method is abstract'''
loop = Loop()
with pytest.raises(NotImplementedError) as excinfo:
_ = loop._halo_read_access(None)
assert ("This method needs to be implemented by the APIs that support "
"distributed memory.") in str(excinfo.value)
def test_fusetrans_error_not_same_parent():
''' Check that we reject attempts to fuse loops which don't share the
same parent '''
loop1 = Loop.create(DataSymbol("i", INTEGER_TYPE),
Literal("1",
INTEGER_TYPE), Literal("10", INTEGER_TYPE),
Literal("1", INTEGER_TYPE), [Return()])
sch1 = Schedule()
sch1.addchild(loop1)
sch2 = Schedule()
loop2 = Loop.create(DataSymbol("j", INTEGER_TYPE),
Literal("1",
INTEGER_TYPE), Literal("10", INTEGER_TYPE),
Literal("1", INTEGER_TYPE), [Return()])
sch2.addchild(loop2)
fuse = LoopFuseTrans()
# Try to fuse loops with different parents
with pytest.raises(TransformationError) as err:
fuse.validate(loop1, loop2)
assert ("Error in LoopFuseTrans transformation. Loops do not have the "
"same parent" in str(err.value))
def __init__(self, parent=None, loop_type=""):
Loop.__init__(self,
parent=parent,
valid_loop_types=["", "colours", "colour"])
self.loop_type = loop_type
# Work out the variable name from the loop type
if self._loop_type == "colours":
tag = "colours_loop_idx"
suggested_name = "colour"
elif self._loop_type == "colour":
tag = "colour_loop_idx"
suggested_name = "cell"
else:
tag = "cell_loop_idx"
suggested_name = "cell"
symtab = self.scope.symbol_table
try:
data_symbol = symtab.lookup_with_tag(tag)
except KeyError:
name = symtab.new_symbol_name(suggested_name)
data_symbol = DataSymbol(name, INTEGER_TYPE)
symtab.add(data_symbol, tag=tag)
self.variable = data_symbol
# Pre-initialise the Loop children # TODO: See issue #440
self.addchild(Literal("NOT_INITIALISED", INTEGER_TYPE,
parent=self)) # start
self.addchild(Literal("NOT_INITIALISED", INTEGER_TYPE,
parent=self)) # stop
self.addchild(Literal("1", INTEGER_TYPE, parent=self)) # step
self.addchild(Schedule(parent=self)) # loop body
def __init__(self, parent=None, topology_name="", loop_type=""):
Loop.__init__(self, parent=parent, valid_loop_types=["inner", "outer"])
self.loop_type = loop_type
if self._loop_type == "inner":
tag = "inner_loop_idx"
suggested_name = "i"
elif self.loop_type == "outer":
tag = "outer_loop_idx"
suggested_name = "j"
symtab = self.scope.symbol_table
try:
self.variable = symtab.lookup_with_tag(tag)
except KeyError:
self.variable = symtab.new_symbol(suggested_name,
tag,
symbol_type=DataSymbol,
datatype=INTEGER_TYPE)
# Pre-initialise the Loop children # TODO: See issue #440
self.addchild(Literal("NOT_INITIALISED", INTEGER_TYPE,
parent=self)) # start
self.addchild(Literal("NOT_INITIALISED", INTEGER_TYPE,
parent=self)) # stop
self.addchild(Literal("1", INTEGER_TYPE, parent=self)) # step
self.addchild(Schedule(parent=self)) # loop body
def test_check_variable():
'''Test the _check_variable utility method behaves as expected'''
with pytest.raises(GenerationError) as info:
Loop._check_variable(None)
assert ("variable property in Loop class should be a DataSymbol but "
"found 'NoneType'." in str(info.value))
with pytest.raises(GenerationError) as info:
Loop._check_variable("hello")
assert ("variable property in Loop class should be a DataSymbol but "
"found 'str'." in str(info.value))
array_type = ArrayType(INTEGER_TYPE, shape=[10, 20])
array_symbol = DataSymbol("my_array", array_type)
with pytest.raises(GenerationError) as info:
Loop._check_variable(array_symbol)
assert ("variable property in Loop class should be a ScalarType but "
"found 'ArrayType'." in str(info.value))
scalar_symbol = DataSymbol("my_array", REAL_TYPE)
with pytest.raises(GenerationError) as info:
Loop._check_variable(scalar_symbol)
assert ("variable property in Loop class should be a scalar integer but "
"found 'REAL'." in str(info.value))
scalar_symbol = DataSymbol("my_array", INTEGER_TYPE)
assert Loop._check_variable(scalar_symbol) is None
def __init__(self, parent=None, variable=None):
# The order in which names are returned in
# get_valid_loop_types depends on the Python implementation
# (as it pulls the values from a dictionary). To make it clear
# that there is no implied ordering here we store
# valid_loop_types as a set, rather than a list.
valid_loop_types = set(
Config.get().api_conf("nemo").get_valid_loop_types())
Loop.__init__(self, parent=parent,
variable=variable,
valid_loop_types=valid_loop_types)
def test_invalid_loop_annotations():
''' Check that the Loop constructor validates any supplied annotations. '''
# Check that we can have 'was_where' on its own
test_loop = Loop(annotations=['was_where'])
assert test_loop.annotations == ['was_where']
# Check that 'was_single_stmt' on its own raises an error
with pytest.raises(InternalError) as err:
Loop(annotations=['was_single_stmt'])
assert ("Loop with the 'was_single_stmt' annotation must also have the "
"'was_where'" in str(err.value))
# Check that it's accepted in combination with 'was_where'
test_loop = Loop(annotations=['was_single_stmt', 'was_where'])
assert test_loop.annotations == ['was_single_stmt', 'was_where']
def create(variable, start, stop, step, children):
'''Create a NemoLoop instance given valid instances of a variable,
start, stop and step nodes, and a list of child nodes for the
loop body.
:param variable: the PSyIR node containing the variable \
of the loop iterator.
:type variable: :py:class:`psyclone.psyir.symbols.DataSymbol`
:param start: the PSyIR node determining the value for the \
start of the loop.
:type start: :py:class:`psyclone.psyir.nodes.Node`
:param end: the PSyIR node determining the value for the end \
of the loop.
:type end: :py:class:`psyclone.psyir.nodes.Node`
:param step: the PSyIR node determining the value for the loop \
step.
:type step: :py:class:`psyclone.psyir.nodes.Node`
:param children: a list of PSyIR nodes contained in the \
loop.
:type children: list of :py:class:`psyclone.psyir.nodes.Node`
:returns: a NemoLoop instance.
:rtype: :py:class:`psyclone.nemo.NemoLoop`
:raises GenerationError: if the arguments to the create method \
are not of the expected type.
'''
Loop._check_variable(variable)
if not isinstance(children, list):
raise GenerationError(
"children argument in create method of NemoLoop class "
"should be a list but found '{0}'."
"".format(type(children).__name__))
# Create the loop
loop = NemoLoop(variable=variable)
schedule = Schedule(parent=loop, children=children)
loop.children = [start, stop, step, schedule]
for child in children:
child.parent = schedule
start.parent = loop
stop.parent = loop
step.parent = loop
# Indicate the type of loop
loop_type_mapping = Config.get().api_conf("nemo") \
.get_loop_type_mapping()
loop.loop_type = loop_type_mapping.get(variable.name, "unknown")
return loop
def test_regiontrans_wrong_children():
''' Check that the validate method raises the expected error if
passed the wrong children of a Node. (e.g. those representing the
bounds of a Loop.) '''
# RegionTrans is abstract so use a concrete sub-class
rtrans = ACCParallelTrans()
# Construct a valid Loop in the PSyIR
parent = Loop(parent=None)
parent.addchild(Literal("1", INTEGER_TYPE, parent))
parent.addchild(Literal("10", INTEGER_TYPE, parent))
parent.addchild(Literal("1", INTEGER_TYPE, parent))
parent.addchild(Schedule(parent=parent))
with pytest.raises(TransformationError) as err:
RegionTrans.validate(rtrans, parent.children)
assert ("Cannot apply a transformation to multiple nodes when one or more "
"is a Schedule" in str(err.value))
def gen_code(self, parent):
if self.field_space == "every":
from psyclone.f2pygen import DeclGen
from psyclone.psyir.nodes import BinaryOperation
dim_var = DeclGen(parent,
datatype="INTEGER",
entity_decls=[self.variable.name])
parent.add(dim_var)
# Update start loop bound
self.start_expr = Literal("1", INTEGER_TYPE, parent=self)
# Update stop loop bound
if self._loop_type == "inner":
index = "1"
elif self._loop_type == "outer":
index = "2"
self.stop_expr = BinaryOperation(BinaryOperation.Operator.SIZE,
parent=self)
self.stop_expr.addchild(
Reference(DataSymbol(self.field_name, INTEGER_TYPE),
parent=self.stop_expr))
self.stop_expr.addchild(
Literal(index, INTEGER_TYPE, parent=self.stop_expr))
else: # one of our spaces so use values provided by the infrastructure
# loop bounds
# TODO: Issue 440. Implement derive types in PSyIR
if self._loop_type == "inner":
self.start_expr = Reference(self.field_space + "%istart",
parent=self)
self.stop_expr = Reference(self.field_space + "%istop",
parent=self)
elif self._loop_type == "outer":
self.start_expr = Reference(self.field_space + "%jstart",
parent=self)
self.stop_expr = Reference(self.field_space + "%jstop",
parent=self)
Loop.gen_code(self, parent)
def gen_code(self, parent):
''' Work out the appropriate loop bounds and then call the base
class to generate the code '''
self.start_expr = Literal("1", INTEGER_TYPE, parent=self)
if self._loop_type == "colours":
self.stop_expr = Reference(DataSymbol("ncolour", INTEGER_TYPE),
parent=self)
elif self._loop_type == "colour":
self.stop_expr = Array(DataSymbol("ncp_ncolour", INTEGER_TYPE),
parent=self)
self.stop_expr.addchild(Reference(
DataSymbol("colour", INTEGER_TYPE)),
parent=self.stop_expr)
else:
# This is a hack as the name is not a valid DataSymbol, it
# is a call to a type-bound function.
self.stop_expr = Reference(DataSymbol(
self.field_name + "%get_ncell()", INTEGER_TYPE),
parent=self)
Loop.gen_code(self, parent)
def test_variable_setter():
'''Check that we can set the _variable property using the variable
setter method and that it raises an exception if an invalid value
is provided.
'''
loop = Loop()
assert loop._variable is None
# valid variable
loop.variable = DataSymbol("var", INTEGER_TYPE)
assert loop.variable.name == "var"
# invalid variable (test_check_variable tests check all ways a
# variable could be invalid. Here we just check that the
# _check_variable() method is called correctly)
with pytest.raises(GenerationError) as excinfo:
loop.variable = None
assert ("variable property in Loop class should be a DataSymbol but "
"found 'NoneType'.") in str(excinfo.value)
def test_parallellooptrans_refuse_codeblock():
''' Check that ParallelLoopTrans.validate() rejects a loop nest that
encloses a CodeBlock. We have to use OMPParallelLoopTrans as
ParallelLoopTrans is abstract. '''
otrans = OMPParallelLoopTrans()
# Construct a valid Loop in the PSyIR with a CodeBlock in its body
parent = Loop.create(DataSymbol("ji", INTEGER_TYPE),
Literal("1",
INTEGER_TYPE), Literal("10", INTEGER_TYPE),
Literal("1", INTEGER_TYPE),
[CodeBlock([], CodeBlock.Structure.STATEMENT, None)])
with pytest.raises(TransformationError) as err:
otrans.validate(parent)
assert ("Nodes of type 'CodeBlock' cannot be enclosed "
"by a OMPParallelLoopTrans transformation" in str(err.value))
def test_variable_getter():
'''Check that the variable property raises an exception if it is
accessed and its value has not been set (is still None).
'''
loop = Loop()
# invalid variable (test_check_variable tests check all ways a
# variable could be invalid. Here we just check that the
# _check_variable() method is called correctly). The particular
# case we want to catch in the code is when the variable has not
# been set, so is None.
with pytest.raises(GenerationError) as excinfo:
_ = loop.variable
assert ("variable property in Loop class should be a DataSymbol but "
"found 'NoneType'.") in str(excinfo.value)
def test_replace_with_error1():
'''Check that the replace_with method raises the expected exception if
the type of node is invalid for the location it is being added
to.
'''
iterator = DataSymbol("i", INTEGER_TYPE)
start = Literal("0", INTEGER_TYPE)
stop = Literal("1", INTEGER_TYPE)
step = Literal("1", INTEGER_TYPE)
loop = Loop.create(iterator, start, stop, step, [])
new_node = Assignment()
# The first child of a loop is the loop start value which should
# be a DataNode.
with pytest.raises(GenerationError) as info:
loop.children[0].replace_with(new_node)
assert ("Item 'Assignment' can't be child 0 of 'Loop'. The valid "
"format is: 'DataNode, DataNode, DataNode, Schedule'"
in str(info.value))
def test_loop_create():
'''Test that the create method in the Loop class correctly
creates a Loop instance.
'''
start = Literal("0", INTEGER_SINGLE_TYPE)
stop = Literal("1", INTEGER_SINGLE_TYPE)
step = Literal("1", INTEGER_SINGLE_TYPE)
child_node = Assignment.create(
Reference(DataSymbol("tmp", REAL_SINGLE_TYPE)),
Reference(DataSymbol("i", REAL_SINGLE_TYPE)))
loop = Loop.create(DataSymbol("i", INTEGER_SINGLE_TYPE), start, stop, step,
[child_node])
schedule = loop.children[3]
assert isinstance(schedule, Schedule)
check_links(loop, [start, stop, step, schedule])
check_links(schedule, [child_node])
result = FortranWriter().loop_node(loop)
assert result == "do i = 0, 1, 1\n tmp = i\nenddo\n"
def test_loop_create_invalid():
'''Test that the create method in a Loop class raises the expected
exception if the provided input is invalid.
'''
zero = Literal("0", INTEGER_SINGLE_TYPE)
one = Literal("1", INTEGER_SINGLE_TYPE)
children = [
Assignment.create(Reference(DataSymbol("x", INTEGER_SINGLE_TYPE)), one)
]
# invalid variable (test_check_variable tests check all ways a
# variable could be invalid. Here we just check that the
# _check_variable() method is called correctly)
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(1, zero, one, one, children)
assert ("variable property in Loop class should be a DataSymbol but "
"found 'int'.") in str(excinfo.value)
variable = DataSymbol("i", INTEGER_TYPE)
# start not a Node.
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(variable, "invalid", one, one, children)
assert ("Item 'str' can't be child 0 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'.") in str(excinfo.value)
# stop not a Node.
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(variable, zero, "invalid", one, children)
assert ("Item 'str' can't be child 1 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'.") in str(excinfo.value)
# step not a Node.
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(variable, zero, one, "invalid", children)
assert ("Item 'str' can't be child 2 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'.") in str(excinfo.value)
# children not a list
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(variable, zero, one, one, "invalid")
assert ("children argument in create method of Loop class should "
"be a list but found 'str'." in str(excinfo.value))
# contents of children list are not Node.
with pytest.raises(GenerationError) as excinfo:
_ = Loop.create(variable, zero, one, one, ["invalid"])
assert ("Item 'str' can't be child 0 of 'Schedule'. The valid format is: "
"'[Statement]*'." in str(excinfo.value))
def apply(self, node, options=None):
'''Apply the ArrayRange2Loop transformation to the specified node. The
node must be an assignment. The rightmost range node in each array
within the assignment is replaced with a loop index and the
assignment is placed within a loop iterating over that
index. The bounds of the loop are determined from the bounds
of the array range on the left hand side of the assignment.
:param node: an Assignment node.
:type node: :py:class:`psyclone.psyir.nodes.Assignment`
'''
self.validate(node)
parent = node.parent
symbol_table = node.scope.symbol_table
loop_variable_name = symbol_table.new_symbol_name(root_name="idx")
loop_variable_symbol = DataSymbol(loop_variable_name, INTEGER_TYPE)
symbol_table.add(loop_variable_symbol)
# Replace the rightmost range found in all arrays with the
# iterator and use the range from the LHS range for the loop
# iteration space.
for array in node.walk(Array):
for idx, child in reversed(list(enumerate(array.children))):
if isinstance(child, Range):
if array is node.lhs:
# Save this range to determine indexing
lhs_range = child
array.children[idx] = Reference(loop_variable_symbol,
parent=array)
break
position = node.position
# Issue #806: If Loop bounds were a Range we would just
# need to provide the range node which would be simpler.
loop = Loop.create(loop_variable_symbol, lhs_range.children[0],
lhs_range.children[1], lhs_range.children[2],
[node])
parent.children[position] = loop
loop.parent = parent
def test_loop_init():
'''Test that a loop instance is created as expected and that it raises
the expected exceptions where appropriate.
'''
loop = Loop()
assert loop.parent is None
assert loop._valid_loop_types == []
assert loop.annotations == []
assert loop._loop_type is None
assert loop._field is None
assert loop._field_name is None
assert loop._field_space is None
assert loop._iteration_space is None
assert loop._kern is None
assert loop._iterates_over == "unknown"
assert loop._variable is None
assert loop._id == ""
# valid variable
loop = Loop(variable=DataSymbol("var", INTEGER_TYPE))
assert loop.variable.name == "var"
# invalid variable (test_check_variable tests check all ways a
# variable could be invalid. Here we just check that the
# _check_variable() method is called correctly)
with pytest.raises(GenerationError) as excinfo:
_ = Loop(variable="hello")
assert ("variable property in Loop class should be a DataSymbol but "
"found 'str'.") in str(excinfo.value)
# valid_loop_types. Note, there is no error checking for this
# variable in the Loop class.
loop = Loop(valid_loop_types=["a"])
assert loop._valid_loop_types == ["a"]
parent = Schedule()
loop = Loop(parent=parent)
assert loop.parent is parent
annotations = ["was_where"]
loop = Loop(annotations=annotations)
assert loop.annotations == annotations
ASSIGN1 = Assignment.create(TMP1, ZERO)
ASSIGN2 = Assignment.create(TMP2, ZERO)
ASSIGN3 = Assignment.create(TMP2, BINARYOPERATION)
ASSIGN4 = Assignment.create(TMP1, TMP2)
ASSIGN5 = Assignment.create(TMP1, NARYOPERATION)
ASSIGN6 = Assignment.create(TMPARRAY, TWO)
# Call
CALL = Call.create(ROUTINE_SYMBOL, [TMP1, BINARYOPERATION])
# If statement
IF_CONDITION = BinaryOperation.create(BinaryOperation.Operator.GT, TMP1, ZERO)
IFBLOCK = IfBlock.create(IF_CONDITION, [ASSIGN3, ASSIGN4])
# Loop
LOOP = Loop.create(INDEX_SYMBOL, INT_ZERO, INT_ONE, INT_ONE, [IFBLOCK])
# KernelSchedule
KERNEL_SCHEDULE = KernelSchedule.create(
"work", SYMBOL_TABLE, [CALL, ASSIGN2, LOOP, ASSIGN5, ASSIGN6])
# Container
CONTAINER_SYMBOL_TABLE = SymbolTable()
CONTAINER = Container.create("CONTAINER", CONTAINER_SYMBOL_TABLE,
[KERNEL_SCHEDULE])
# Import data from another container
EXTERNAL_CONTAINER = ContainerSymbol("some_mod")
CONTAINER_SYMBOL_TABLE.add(EXTERNAL_CONTAINER)
EXTERNAL_VAR = DataSymbol("some_var",
INTEGER_TYPE,
def test_children_validation():
''' Test that nodes are validated when inserted as children of other
nodes. For simplicity we use Node subclasses to test this functionality
across a range of possible operations.
The specific logic of each validate method will be tested individually
inside each Node test file.
'''
assignment = Assignment()
return_stmt = Return()
reference = Reference(DataSymbol("a", INTEGER_TYPE))
assert isinstance(assignment.children, (ChildrenList, list))
# Try adding a invalid child (e.g. a return_stmt into an assingment)
with pytest.raises(GenerationError) as error:
assignment.addchild(return_stmt)
assert "Item 'Return' can't be child 0 of 'Assignment'. The valid format" \
" is: 'DataNode, DataNode'." in str(error.value)
# The same behaviour occurs when list insertion operations are used.
with pytest.raises(GenerationError):
assignment.children.append(return_stmt)
with pytest.raises(GenerationError):
assignment.children[0] = return_stmt
with pytest.raises(GenerationError):
assignment.children.insert(0, return_stmt)
with pytest.raises(GenerationError):
assignment.children.extend([return_stmt])
with pytest.raises(GenerationError):
assignment.children = assignment.children + [return_stmt]
# Valid nodes are accepted
assignment.addchild(reference)
# Check displaced items are also be checked when needed
start = Literal("0", INTEGER_TYPE)
stop = Literal("1", INTEGER_TYPE)
step = Literal("2", INTEGER_TYPE)
child_node = Assignment.create(Reference(DataSymbol("tmp", REAL_TYPE)),
Reference(DataSymbol("i", REAL_TYPE)))
loop_variable = DataSymbol("idx", INTEGER_TYPE)
loop = Loop.create(loop_variable, start, stop, step, [child_node])
with pytest.raises(GenerationError):
loop.children.insert(1, Literal("0", INTEGER_TYPE))
with pytest.raises(GenerationError):
loop.children.remove(stop)
with pytest.raises(GenerationError):
del loop.children[2]
with pytest.raises(GenerationError):
loop.children.pop(2)
with pytest.raises(GenerationError):
loop.children.reverse()
# But the in the right circumstances they work fine
assert isinstance(loop.children.pop(), Schedule)
loop.children.reverse()
assert loop.children[0].value == "2"
def test_loop_children_validation():
'''Test that children added to Loop are validated. Loop accepts
3 DataNodes and a Schedule.
'''
loop = Loop()
datanode1 = Literal("1", INTEGER_SINGLE_TYPE)
datanode2 = Literal("2", INTEGER_SINGLE_TYPE)
datanode3 = Literal("3", INTEGER_SINGLE_TYPE)
schedule = Schedule(parent=loop)
# First child
with pytest.raises(GenerationError) as excinfo:
loop.addchild(schedule)
assert ("Item 'Schedule' can't be child 0 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'." in str(excinfo.value))
loop.addchild(datanode1)
# Second child
with pytest.raises(GenerationError) as excinfo:
loop.addchild(schedule)
assert ("Item 'Schedule' can't be child 1 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'." in str(excinfo.value))
loop.addchild(datanode2)
# Third child
with pytest.raises(GenerationError) as excinfo:
loop.addchild(schedule)
assert ("Item 'Schedule' can't be child 2 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'." in str(excinfo.value))
loop.addchild(datanode3)
# Fourth child
with pytest.raises(GenerationError) as excinfo:
loop.addchild(datanode1)
assert ("Item 'Literal' can't be child 3 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'." in str(excinfo.value))
loop.addchild(schedule)
# Additional children
with pytest.raises(GenerationError) as excinfo:
loop.addchild(schedule)
assert ("Item 'Schedule' can't be child 4 of 'Loop'. The valid format is: "
"'DataNode, DataNode, DataNode, Schedule'." in str(excinfo.value))
def create_psyir_tree():
''' Create an example PSyIR Tree.
:returns: an example PSyIR tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container`
'''
# Symbol table, symbols and scalar datatypes
symbol_table = SymbolTable()
arg1 = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_TYPE,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE))
symbol_table.specify_argument_list([arg1])
tmp_symbol = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_DOUBLE_TYPE)
index_symbol = symbol_table.new_symbol(root_name="i",
symbol_type=DataSymbol,
datatype=INTEGER4_TYPE)
real_kind = symbol_table.new_symbol(root_name="RKIND",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE,
constant_value=8)
routine_symbol = RoutineSymbol("my_sub")
# Array using precision defined by another symbol
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, real_kind)
array = symbol_table.new_symbol(root_name="a",
symbol_type=DataSymbol,
datatype=ArrayType(scalar_type, [10]))
# Nodes which do not have Nodes as children and (some) predefined
# scalar datatypes
# TODO: Issue #1136 looks at how to avoid all of the _x versions
zero_1 = Literal("0.0", REAL_TYPE)
zero_2 = Literal("0.0", REAL_TYPE)
zero_3 = Literal("0.0", REAL_TYPE)
one_1 = Literal("1.0", REAL4_TYPE)
one_2 = Literal("1.0", REAL4_TYPE)
one_3 = Literal("1.0", REAL4_TYPE)
two = Literal("2.0", scalar_type)
int_zero = Literal("0", INTEGER_SINGLE_TYPE)
int_one_1 = Literal("1", INTEGER8_TYPE)
int_one_2 = Literal("1", INTEGER8_TYPE)
int_one_3 = Literal("1", INTEGER8_TYPE)
int_one_4 = Literal("1", INTEGER8_TYPE)
tmp1_1 = Reference(arg1)
tmp1_2 = Reference(arg1)
tmp1_3 = Reference(arg1)
tmp1_4 = Reference(arg1)
tmp1_5 = Reference(arg1)
tmp1_6 = Reference(arg1)
tmp2_1 = Reference(tmp_symbol)
tmp2_2 = Reference(tmp_symbol)
tmp2_3 = Reference(tmp_symbol)
tmp2_4 = Reference(tmp_symbol)
tmp2_5 = Reference(tmp_symbol)
tmp2_6 = Reference(tmp_symbol)
# Unary Operation
oper = UnaryOperation.Operator.SIN
unaryoperation_1 = UnaryOperation.create(oper, tmp2_1)
unaryoperation_2 = UnaryOperation.create(oper, tmp2_2)
# Binary Operation
oper = BinaryOperation.Operator.ADD
binaryoperation_1 = BinaryOperation.create(oper, one_1, unaryoperation_1)
binaryoperation_2 = BinaryOperation.create(oper, one_2, unaryoperation_2)
# Nary Operation
oper = NaryOperation.Operator.MAX
naryoperation = NaryOperation.create(oper, [tmp1_1, tmp2_3, one_3])
# Array reference using a range
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(array), int_one_1)
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(array), int_one_2)
my_range = Range.create(lbound, ubound)
tmparray = ArrayReference.create(array, [my_range])
# Assignments
assign1 = Assignment.create(tmp1_2, zero_1)
assign2 = Assignment.create(tmp2_4, zero_2)
assign3 = Assignment.create(tmp2_5, binaryoperation_1)
assign4 = Assignment.create(tmp1_3, tmp2_6)
assign5 = Assignment.create(tmp1_4, naryoperation)
assign6 = Assignment.create(tmparray, two)
# Call
call = Call.create(routine_symbol, [tmp1_5, binaryoperation_2])
# If statement
if_condition = BinaryOperation.create(BinaryOperation.Operator.GT, tmp1_6,
zero_3)
ifblock = IfBlock.create(if_condition, [assign3, assign4])
# Loop
loop = Loop.create(index_symbol, int_zero, int_one_3, int_one_4, [ifblock])
# KernelSchedule
kernel_schedule = KernelSchedule.create(
"work", symbol_table, [assign1, call, assign2, loop, assign5, assign6])
# Container
container_symbol_table = SymbolTable()
container = Container.create("CONTAINER", container_symbol_table,
[kernel_schedule])
# Import data from another container
external_container = ContainerSymbol("some_mod")
container_symbol_table.add(external_container)
external_var = DataSymbol("some_var",
INTEGER_TYPE,
interface=GlobalInterface(external_container))
container_symbol_table.add(external_var)
routine_symbol.interface = GlobalInterface(external_container)
container_symbol_table.add(routine_symbol)
return container
def test_fusetrans_error_incomplete():
''' Check that we reject attempts to fuse loops which are incomplete. '''
sch = Schedule()
loop1 = Loop(variable=DataSymbol("i", INTEGER_TYPE))
loop2 = Loop(variable=DataSymbol("j", INTEGER_TYPE))
sch.addchild(loop1)
sch.addchild(loop2)
fuse = LoopFuseTrans()
# Check first loop
with pytest.raises(TransformationError) as err:
fuse.validate(loop1, loop2)
assert ("Error in LoopFuseTrans transformation. The target loop must have "
"four children but found: []" in str(err.value))
loop1.addchild(Literal("start", INTEGER_TYPE))
loop1.addchild(Literal("stop", INTEGER_TYPE))
loop1.addchild(Literal("step", INTEGER_TYPE))
loop1.addchild(Schedule())
loop1.loop_body.addchild(Return())
# Check second loop
with pytest.raises(TransformationError) as err:
fuse.validate(loop1, loop2)
assert ("Error in LoopFuseTrans transformation. The target loop must have "
"four children but found: []" in str(err.value))
loop2.addchild(Literal("start", INTEGER_TYPE))
loop2.addchild(Literal("stop", INTEGER_TYPE))
loop2.addchild(Literal("step", INTEGER_TYPE))
loop2.addchild(Schedule())
loop2.loop_body.addchild(Return())
# Validation should now pass
fuse.validate(loop1, loop2)
def apply(self, node, options=None):
'''Apply the MATMUL intrinsic conversion transformation to the
specified node. This node must be a MATMUL
BinaryOperation. Currently only the matrix vector version of
MATMUL is supported. The arguments are permitted to have
additional dimensions (i.e. more than 2 for the matrix and
more than 1 for the vector) but the matrix can only have two
indices which are ranges and these must be the first two
indices and the vector can only have one index that is a range
and this must be the first index. Further, the ranges must be
for the full index space for that dimension (i.e. array
subsections are not supported). If the transformation is
successful then an assignment which includes a MATMUL
BinaryOperation node is converted to equivalent inline code.
:param node: a MATMUL Binary-Operation node.
:type node: :py:class:`psyclone.psyGen.BinaryOperation`
:param options: a dictionary with options for transformations.
:type options: dictionary of string:values or None
'''
# pylint: disable=too-many-locals
self.validate(node)
assignment = node.parent
matrix = node.children[0]
vector = node.children[1]
result = node.parent.lhs
result_symbol = result.symbol
# Create new i and j loop iterators.
symbol_table = node.scope.symbol_table
i_loop_symbol = symbol_table.new_symbol("i",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE)
j_loop_symbol = symbol_table.new_symbol("j",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE)
# Create "result(i)"
result_dims = [Reference(i_loop_symbol)]
if len(result.children) > 1:
# Add any additional dimensions (in case of an array slice)
for child in result.children[1:]:
result_dims.append(child.copy())
result_ref = ArrayReference.create(result_symbol, result_dims)
# Create "vector(j)"
vector_dims = [Reference(j_loop_symbol)]
if len(vector.children) > 1:
# Add any additional dimensions (in case of an array slice)
for child in vector.children[1:]:
vector_dims.append(child.copy())
vector_array_reference = ArrayReference.create(vector.symbol,
vector_dims)
# Create "matrix(i,j)"
array_dims = [Reference(i_loop_symbol), Reference(j_loop_symbol)]
if len(matrix.children) > 2:
# Add any additional dimensions (in case of an array slice)
for child in matrix.children[2:]:
array_dims.append(child.copy())
matrix_array_reference = ArrayReference.create(matrix.symbol,
array_dims)
# Create "matrix(i,j) * vector(j)"
multiply = BinaryOperation.create(BinaryOperation.Operator.MUL,
matrix_array_reference,
vector_array_reference)
# Create "result(i) + matrix(i,j) * vector(j)"
rhs = BinaryOperation.create(BinaryOperation.Operator.ADD, result_ref,
multiply)
# Create "result(i) = result(i) + matrix(i,j) * vector(j)"
assign = Assignment.create(result_ref.copy(), rhs)
# Create j loop and add the above code as a child
# Work out the bounds
lower_bound, upper_bound, step = _get_array_bound(vector, 0)
jloop = Loop.create(j_loop_symbol, lower_bound, upper_bound, step,
[assign])
# Create "result(i) = 0.0"
assign = Assignment.create(result_ref.copy(),
Literal("0.0", REAL_TYPE))
# Create i loop and add assigment and j loop as children
lower_bound, upper_bound, step = _get_array_bound(matrix, 0)
iloop = Loop.create(i_loop_symbol, lower_bound, upper_bound, step,
[assign, jloop])
# Add the new code to the PSyIR
assignment.parent.children.insert(assignment.position, iloop)
# remove the original matmul
assignment.parent.children.remove(assignment)
def test_fusetrans_error_not_same_parent():
''' Check that we reject attempts to fuse loops which don't share the
same parent '''
from psyclone.transformations import LoopFuseTrans
sch1 = Schedule()
sch2 = Schedule()
loop1 = Loop(variable=DataSymbol("i", INTEGER_TYPE), parent=sch1)
loop2 = Loop(variable=DataSymbol("j", INTEGER_TYPE), parent=sch2)
sch1.addchild(loop1)
sch2.addchild(loop2)
loop1.addchild(Literal("1", INTEGER_TYPE, parent=loop1)) # start
loop1.addchild(Literal("10", INTEGER_TYPE, parent=loop1)) # stop
loop1.addchild(Literal("1", INTEGER_TYPE, parent=loop1)) # step
loop1.addchild(Schedule(parent=loop1)) # loop body
loop2.addchild(Literal("1", INTEGER_TYPE, parent=loop2)) # start
loop2.addchild(Literal("10", INTEGER_TYPE, parent=loop2)) # stop
loop2.addchild(Literal("1", INTEGER_TYPE, parent=loop2)) # step
loop2.addchild(Schedule(parent=loop2)) # loop body
fuse = LoopFuseTrans()
# Try to fuse loops with different parents
with pytest.raises(TransformationError) as err:
fuse.validate(loop1, loop2)
assert ("Error in LoopFuseTrans transformation. Loops do not have the "
"same parent" in str(err.value))
def create_psyir_tree():
''' Create an example PSyIR Tree.
:returns: an example PSyIR tree.
:rtype: :py:class:`psyclone.psyir.nodes.Container`
'''
# Symbol table, symbols and scalar datatypes
symbol_table = SymbolTable()
arg1 = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_TYPE,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE))
symbol_table.specify_argument_list([arg1])
tmp_symbol = symbol_table.new_symbol(symbol_type=DataSymbol,
datatype=REAL_DOUBLE_TYPE)
index_symbol = symbol_table.new_symbol(root_name="i",
symbol_type=DataSymbol,
datatype=INTEGER4_TYPE)
real_kind = symbol_table.new_symbol(root_name="RKIND",
symbol_type=DataSymbol,
datatype=INTEGER_TYPE,
constant_value=8)
routine_symbol = RoutineSymbol("my_sub")
# Array using precision defined by another symbol
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, real_kind)
array = symbol_table.new_symbol(root_name="a",
symbol_type=DataSymbol,
datatype=ArrayType(scalar_type, [10]))
# Make generators for nodes which do not have other Nodes as children,
# with some predefined scalar datatypes
def zero():
return Literal("0.0", REAL_TYPE)
def one():
return Literal("1.0", REAL4_TYPE)
def two():
return Literal("2.0", scalar_type)
def int_zero():
return Literal("0", INTEGER_SINGLE_TYPE)
def int_one():
return Literal("1", INTEGER8_TYPE)
def tmp1():
return Reference(arg1)
def tmp2():
return Reference(tmp_symbol)
# Unary Operation
oper = UnaryOperation.Operator.SIN
unaryoperation = UnaryOperation.create(oper, tmp2())
# Binary Operation
oper = BinaryOperation.Operator.ADD
binaryoperation = BinaryOperation.create(oper, one(), unaryoperation)
# Nary Operation
oper = NaryOperation.Operator.MAX
naryoperation = NaryOperation.create(oper, [tmp1(), tmp2(), one()])
# Array reference using a range
lbound = BinaryOperation.create(BinaryOperation.Operator.LBOUND,
Reference(array), int_one())
ubound = BinaryOperation.create(BinaryOperation.Operator.UBOUND,
Reference(array), int_one())
my_range = Range.create(lbound, ubound)
tmparray = ArrayReference.create(array, [my_range])
# Assignments
assign1 = Assignment.create(tmp1(), zero())
assign2 = Assignment.create(tmp2(), zero())
assign3 = Assignment.create(tmp2(), binaryoperation)
assign4 = Assignment.create(tmp1(), tmp2())
assign5 = Assignment.create(tmp1(), naryoperation)
assign6 = Assignment.create(tmparray, two())
# Call
call = Call.create(routine_symbol, [tmp1(), binaryoperation.copy()])
# If statement
if_condition = BinaryOperation.create(BinaryOperation.Operator.GT, tmp1(),
zero())
ifblock = IfBlock.create(if_condition, [assign3, assign4])
# Loop
loop = Loop.create(index_symbol, int_zero(), int_one(), int_one(),
[ifblock])
# KernelSchedule
kernel_schedule = KernelSchedule.create(
"work", symbol_table, [assign1, call, assign2, loop, assign5, assign6])
# Container
container_symbol_table = SymbolTable()
container = Container.create("CONTAINER", container_symbol_table,
[kernel_schedule])
# Import data from another container
external_container = ContainerSymbol("some_mod")
container_symbol_table.add(external_container)
external_var = DataSymbol("some_var",
INTEGER_TYPE,
interface=GlobalInterface(external_container))
container_symbol_table.add(external_var)
routine_symbol.interface = GlobalInterface(external_container)
container_symbol_table.add(routine_symbol)
return container
def __init__(self, parent=None, variable=None):
valid_loop_types = Config.get().api_conf("nemo").get_valid_loop_types()
Loop.__init__(self, parent=parent,
variable=variable,
valid_loop_types=valid_loop_types)
def test_loop_navigation_properties():
# pylint: disable=too-many-statements
''' Tests the start_expr, stop_expr, step_expr and loop_body
setter and getter properties.
'''
loop = Loop()
# Properties return an error if the node is incomplete
error_str = ("Loop is incomplete. It should have exactly 4 "
"children, but found")
with pytest.raises(InternalError) as err:
_ = loop.start_expr
assert error_str in str(err.value)
loop.addchild(Literal("start", INTEGER_SINGLE_TYPE))
loop.addchild(Literal("stop", INTEGER_SINGLE_TYPE))
loop.addchild(Literal("step", INTEGER_SINGLE_TYPE))
# If it's not fully complete, it still returns an error
with pytest.raises(InternalError) as err:
_ = loop.start_expr
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
_ = loop.stop_expr
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
_ = loop.step_expr
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
_ = loop.loop_body
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
loop.start_expr = Literal("invalid", INTEGER_SINGLE_TYPE)
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
loop.stop_expr = Literal("invalid", INTEGER_SINGLE_TYPE)
assert error_str in str(err.value)
with pytest.raises(InternalError) as err:
loop.step_expr = Literal("invalid", INTEGER_SINGLE_TYPE)
assert error_str in str(err.value)
# Check that Getters properties work
loop.addchild(Schedule(parent=loop))
loop.loop_body.addchild(Return(parent=loop.loop_body))
assert loop.start_expr.value == "start"
assert loop.stop_expr.value == "stop"
assert loop.step_expr.value == "step"
assert isinstance(loop.loop_body[0], Return)
# Test Setters
loop.start_expr = Literal("newstart", INTEGER_SINGLE_TYPE)
loop.stop_expr = Literal("newstop", INTEGER_SINGLE_TYPE)
loop.step_expr = Literal("newstep", INTEGER_SINGLE_TYPE)
assert loop.start_expr.value == "newstart"
assert loop.stop_expr.value == "newstop"
assert loop.step_expr.value == "newstep"
def test_profile_basic(capsys):
'''Check basic functionality: node names, schedule view.
'''
Profiler.set_options([Profiler.INVOKES])
_, invoke = get_invoke("test11_different_iterates_over_one_invoke.f90",
"gocean1.0",
idx=0,
dist_mem=False)
# This test expects constant loop bounds
invoke.schedule._const_loop_bounds = True
Profiler.add_profile_nodes(invoke.schedule, Loop)
assert isinstance(invoke.schedule[0], ProfileNode)
invoke.schedule.view()
out, _ = capsys.readouterr()
gsched = colored("GOInvokeSchedule", GOInvokeSchedule._colour)
sched = colored("Schedule", Schedule._colour)
loop = Loop().coloured_name(True)
profile = invoke.schedule[0].coloured_name(True)
# Do one test based on schedule view, to make sure colouring
# and indentation is correct
expected = (gsched + "[invoke='invoke_0', Constant loop bounds=True]\n"
" 0: " + profile + "[]\n"
" " + sched + "[]\n"
" 0: " + loop +
"[type='outer', field_space='go_cv', "
"it_space='go_internal_pts']\n")
assert expected in out
prt = ProfileTrans()
# Insert a profile call between outer and inner loop.
# This tests that we find the subroutine node even
# if it is not the immediate parent.
new_sched, _ = prt.apply(invoke.schedule[0].profile_body[0].loop_body[0])
new_sched_str = str(new_sched)
correct = ("""GOInvokeSchedule[invoke='invoke_0', \
Constant loop bounds=True]:
ProfileStart[var=profile_psy_data]
GOLoop[id:'', variable:'j', loop_type:'outer']
Literal[value:'2', Scalar<INTEGER, UNDEFINED>]
Literal[value:'jstop-1', Scalar<INTEGER, UNDEFINED>]
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Schedule:
ProfileStart[var=profile_psy_data_1]
GOLoop[id:'', variable:'i', loop_type:'inner']
Literal[value:'2', Scalar<INTEGER, UNDEFINED>]
Literal[value:'istop', Scalar<INTEGER, UNDEFINED>]
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Schedule:
kern call: compute_cv_code
End Schedule
End GOLoop
ProfileEnd
End Schedule
End GOLoop
GOLoop[id:'', variable:'j', loop_type:'outer']
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Literal[value:'jstop+1', Scalar<INTEGER, UNDEFINED>]
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Schedule:
GOLoop[id:'', variable:'i', loop_type:'inner']
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Literal[value:'istop+1', Scalar<INTEGER, UNDEFINED>]
Literal[value:'1', Scalar<INTEGER, UNDEFINED>]
Schedule:
kern call: bc_ssh_code
End Schedule
End GOLoop
End Schedule
End GOLoop
ProfileEnd
End Schedule""")
assert correct in new_sched_str
Profiler.set_options(None)