def test_if_with_position_append():
''' Check that IfThenGen.add() correctly uses the position
argument when *append* is specified. '''
module = ModuleGen(name="testmodule")
clause = "a < b"
if_statement = IfThenGen(module, clause)
com1 = CommentGen(if_statement, "HELLO")
if_statement.add(com1)
if_statement.add(CommentGen(if_statement, "GOODBYE"), position=["append"])
module.add(if_statement)
print str(module.root)
lines = str(module.root).splitlines()
assert "IF (" + clause + ") THEN" in lines[3]
assert "!HELLO" in lines[4]
assert "!GOODBYE" in lines[5]
assert "END IF" in lines[6]
def test_comment():
''' check that a comment gets created succesfully. '''
module = ModuleGen(name="testmodule")
content = "HELLO"
comment = CommentGen(module, content)
module.add(comment)
lines = str(module.root).splitlines()
assert "!" + content in lines[3]
def test_basegen_first():
'''Check that we can insert an object as the first child'''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var1"]))
sub.add(CommentGen(sub, " hello"), position=["first"])
cindex = line_number(sub.root, "hello")
assert cindex == 1
def test_basegen_append():
'''Check that we can append an object to the tree'''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var1"]))
sub.add(CommentGen(sub, " hello"), position=["append"])
cindex = line_number(sub.root, "hello")
assert cindex == 3
def test_basegen_append_default():
''' Check if no position argument is supplied to BaseGen.add() then it
defaults to appending '''
from psyclone.f2pygen import BaseGen
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
BaseGen.add(sub, DeclGen(sub, datatype="integer", entity_decls=["var1"]))
BaseGen.add(sub, CommentGen(sub, " hello"))
cindex = line_number(sub.root, "hello")
assert cindex == 3
def test_if_content():
''' Check that the content of an if gets created successfully. '''
module = ModuleGen(name="testmodule")
clause = "a < b"
if_statement = IfThenGen(module, clause)
if_statement.add(CommentGen(if_statement, "HELLO"))
module.add(if_statement)
lines = str(module.root).splitlines()
assert "IF (" + clause + ") THEN" in lines[3]
assert "!HELLO" in lines[4]
assert "END IF" in lines[5]
def gen_code(self, parent):
# pylint: disable=arguments-differ
'''
Generates the code required for read-only verification of one or
more Nodes. It uses the PSyData API (via the base class PSyDataNode)
to create the required callbacks that will allow a library to
validate that read-only data is not modified.
:param parent: the parent of this Node in the PSyIR.
:type parent: :py:class:`psyclone.psyir.nodes.Node`.
'''
# Determine the variables to validate:
variables_info = VariablesAccessInfo(self)
read_only = []
for var_name in variables_info:
if variables_info[var_name].is_read_only():
read_only.append(var_name)
# Add a callback here so that derived classes can adjust the list
# of variables to provide, or the suffix used (which might
# depend on the variable name which could create clashes).
self.update_vars_and_postname()
options = {'pre_var_list': read_only, 'post_var_list': read_only}
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ReadOnlyVerifyStart"))
parent.add(CommentGen(parent, ""))
super(ReadOnlyVerifyNode, self).gen_code(parent, options)
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ReadOnlyVerifyEnd"))
parent.add(CommentGen(parent, ""))
def gen_code(self, parent):
# pylint: disable=arguments-differ
'''
Generates the code required for NAN/infinite verification of the
parameters of one or more Nodes. It uses the PSyData API (via
the base class PSyDataNode) to create the required callbacks
that will allow a library to do checks on parameters.
:param parent: the parent of this Node in the PSyIR.
:type parent: :py:class:`psyclone.psyir.nodes.Node`.
'''
# pylint: disable=import-outside-toplevel
# This cannot be moved to the top, it would cause a circular import
from psyclone.psyir.tools.dependency_tools import DependencyTools
# Determine the variables to check:
dep = DependencyTools()
input_list, output_list = dep.get_in_out_parameters(self)
options = {'pre_var_list': input_list, 'post_var_list': output_list}
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " NanTestStart"))
parent.add(CommentGen(parent, ""))
super(NanTestNode, self).gen_code(parent, options)
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " NanTestEnd"))
parent.add(CommentGen(parent, ""))
def test_basegen_after_index():
'''Check that we can insert an object using "after_index"'''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var1"]))
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var2"]))
sub.add(CommentGen(sub, " hello"), position=["after_index", 1])
# The code checked by line_number() *includes* the SUBROUTINE
# statement (which is obviously not a child of the SubroutineGen
# object) and therefore the index it returns is 1 greater than we
# might expect.
assert line_number(sub.root, "hello") == 3
def test_basegen_before_error():
'''Check that we raise an error when attempting to insert an object
before another object that is not present in the tree'''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var1"]))
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var2"]))
# Create an object but do not add it as a child of sub
dgen = DeclGen(sub, datatype="real", entity_decls=["rvar1"])
# Try to add an object before the orphan dgen
with pytest.raises(RuntimeError) as err:
sub.add(CommentGen(sub, " hello"), position=["before", dgen])
assert "Failed to find supplied object" in str(err)
def test_imp_none_in_module_with_use_and_decs_and_comments():
''' test that implicit none is added after any use statements
and before any declarations in a module in the presence of
comments when auto (the default) is used for insertion'''
module = ModuleGen(name="testmodule", implicitnone=False)
module.add(DeclGen(module, datatype="integer", entity_decls=["var1"]))
module.add(TypeDeclGen(module, datatype="my_type", entity_decls=["type1"]))
module.add(UseGen(module, "fred"))
for idx in [0, 1, 2, 3]:
module.add(CommentGen(module, " hello " + str(idx)),
position=["before_index", 2 * idx])
module.add(ImplicitNoneGen(module))
in_idx = line_number(module.root, "IMPLICIT NONE")
assert in_idx == 3
def test_if_add_use():
''' Check that IfThenGen.add() correctly handles the case
when it is passed a UseGen object '''
module = ModuleGen(name="testmodule")
clause = "a < b"
if_statement = IfThenGen(module, clause)
if_statement.add(CommentGen(if_statement, "GOODBYE"))
if_statement.add(UseGen(if_statement, name="dibna"))
module.add(if_statement)
print str(module.root)
use_line = line_number(module.root, "USE dibna")
if_line = line_number(module.root, "IF (" + clause + ") THEN")
# The use statement must come before the if..then block
assert use_line < if_line
def gen_code(self, parent):
'''
Generates the code required for extraction of one or more Nodes. \
For now it inserts comments before and after the code belonging \
to all the children of this ExtractNode. These comments will be \
replaced by calls to write out arguments of extracted Node(s) or \
Kernel(s) in Issue #234.
:param parent: the parent of this Node in the PSyIR.
:type parent: :py:class:`psyclone.psyGen.Node`.
'''
from psyclone.f2pygen import CommentGen
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ExtractStart"))
parent.add(
CommentGen(parent, " CALL write_extract_arguments(argument_list)"))
parent.add(CommentGen(parent, ""))
for child in self.children:
child.gen_code(parent)
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ExtractEnd"))
parent.add(CommentGen(parent, ""))
def gen_code(self, parent):
# pylint: disable=arguments-differ
'''
Generates the code required for extraction of one or more Nodes.
It uses the PSyData API (via the base class PSyDataNode) to create
the required callbacks that will allow a library to write the
kernel data to a file.
:param parent: the parent of this Node in the PSyIR.
:type parent: :py:class:`psyclone.psyir.nodes.Node`.
'''
# Determine the variables to write:
from psyclone.psyir.tools.dependency_tools import DependencyTools
dep = DependencyTools()
self._input_list, self._output_list = dep.get_in_out_parameters(self)
# Add a callback here so that derived classes can adjust the list
# of variables to provide, or the suffix used (which might
# depend on the variable name which could create clashes).
self.update_vars_and_postname()
options = {
'pre_var_list': self._input_list,
'post_var_list': self._output_list,
'post_var_postfix': self._post_name
}
from psyclone.f2pygen import CommentGen
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ExtractStart"))
parent.add(CommentGen(parent, ""))
super(ExtractNode, self).gen_code(parent, options)
parent.add(CommentGen(parent, ""))
parent.add(CommentGen(parent, " ExtractEnd"))
parent.add(CommentGen(parent, ""))
def create_driver(self, input_list, output_list):
# pylint: disable=too-many-locals, too-many-statements
'''This function creates a driver that can read the
output created by the extraction code. This is a stand-alone
program that will read the input data, calls the kernels/
instrumented region, and then compares the results with the
stored results in the file.
TODO: #644: we need type information here.
:param input_list: list of variables that are input parameters.
:type input_list: list of str
:param output_list: list of variables that are output parameters.
:type output_list: list or str
'''
from psyclone.f2pygen import AllocateGen, AssignGen, CallGen,\
CommentGen, DeclGen, ModuleGen, SubroutineGen, UseGen, \
TypeDeclGen
from psyclone.gocean1p0 import GOSymbolTable
from psyclone.psyir.symbols import Symbol
all_vars = list(set(input_list).union(set(output_list)))
all_vars.sort()
module_name, region_name = self.region_identifier
module = ModuleGen(name=module_name)
prog = SubroutineGen(parent=module, name=module_name+"_code",
implicitnone=True)
module.add(prog)
use = UseGen(prog, self.add_psydata_class_prefix("psy_data_mod"),
only=True,
funcnames=[self.add_psydata_class_prefix("PSyDataType")])
prog.add(use)
# Use a symbol table to make sure all variable names are unique
sym_table = GOSymbolTable()
sym = Symbol("PSyDataType")
sym_table.add(sym)
psy_data = sym_table.new_symbol_name(self.add_psydata_class_prefix
("psy_data"))
sym_table.add(Symbol(psy_data))
var_decl = TypeDeclGen(prog, datatype=self.add_psydata_class_prefix
("PSyDataType"),
entity_decls=[psy_data])
prog.add(var_decl)
call = CallGen(prog,
"{0}%OpenRead(\"{1}\", \"{2}\")"
.format(psy_data, module_name, region_name))
prog.add(call)
post_suffix = self._post_name
# Variables might need to be renamed in order to guarantee unique
# variable names in the driver: An example of this would be if the
# user code contains a variable 'dx', and the kernel takes a
# property 'dx' as well. In the original code that is no problem,
# since the property is used via field%grid%dx. But the stand-alone
# driver renames field%grid%dx to dx, which can cause a name clash.
# Similar problems can exist with any user defined type, since all
# user defined types are rewritten to just use the field name.
# We use a mapping to support renaming of variables: it takes as
# key the variable as used in the original program (e.g. 'dx' from
# an expression like field%grid%dx), and maps it to a unique local
# name (e.g. dx_0).
rename_variable = {}
for var_name in all_vars:
# TODO #644: we need to identify arrays!!
# Support GOcean properties, which are accessed via a
# derived type (e.g. 'fld%grid%dx'). In this stand-alone
# driver we don't have the derived type, instead we create
# variable based on the field in the derived type ('dx'
# in the example above), and pass this variable to the
# instrumented code.
last_percent = var_name.rfind("%")
if last_percent > -1:
# Strip off the derived type, and only leave the last
# field, which is used as the local variable name.
local_name = var_name[last_percent+1:]
else:
# No derived type, so we can just use the
# variable name directly in the driver
local_name = var_name
unique_local_name = sym_table.new_symbol_name(local_name)
rename_variable[local_name] = unique_local_name
sym_table.add(Symbol(unique_local_name))
local_name = unique_local_name
# TODO: #644 - we need to identify arrays!!
# Any variable used needs to be defined. We also need
# to handle the kind property better and not rely on
# a hard-coded value.
decl = DeclGen(prog, "real", [local_name], kind="8",
dimension=":,:", allocatable=True)
prog.add(decl)
is_input = var_name in input_list
is_output = var_name in output_list
if is_input and not is_output:
# We only need the pre-variable, and we can read
# it from the file (this call also allocates space for it).
call = CallGen(prog,
"{0}%ReadVariable(\"{1}\", {2})"
.format(psy_data, var_name, local_name))
prog.add(call)
elif is_input:
# Now must be input and output:
# First read the pre-variable (which also allocates it):
call = CallGen(prog,
"{0}%ReadVariable(\"{1}\", {2})"
.format(psy_data, var_name, local_name))
prog.add(call)
# Then declare the post variable, and and read its values
# (ReadVariable will also allocate it)
sym = Symbol(local_name+post_suffix)
sym_table.add(sym)
decl = DeclGen(prog, "real", [local_name+post_suffix],
dimension=":,:", kind="8", allocatable=True)
prog.add(decl)
call = CallGen(prog,
"{0}%ReadVariable(\"{1}{3}\", {2}{3})"
.format(psy_data, var_name, local_name,
post_suffix))
prog.add(call)
else:
# Now the variable is output only. We need to read the
# post variable in, and create and allocate a pre variable
# with the same size as the post
sym = Symbol(local_name+post_suffix)
sym_table.add(sym)
decl = DeclGen(prog, "real", [local_name+post_suffix],
dimension=":,:", kind="8", allocatable=True)
prog.add(decl)
call = CallGen(prog,
"{0}%ReadVariable(\"{1}{3}\", {2}{3})"
.format(psy_data, var_name, local_name,
post_suffix))
prog.add(call)
decl = DeclGen(prog, "real", [local_name], kind="8",
dimension=":,:", allocatable=True)
prog.add(decl)
alloc = AllocateGen(prog, [var_name],
mold="{0}".format(local_name +
post_suffix))
prog.add(alloc)
# Initialise the variable with 0, since it might contain
# values that are not set at all (halo regions, or a
# kernel might not set all values). This way the array
# comparison with the post value works as expected
# TODO #644 - create the right "0.0" type here (e.g.
# 0.0d0, ...)
assign = AssignGen(prog, local_name, "0.0d0")
prog.add(assign)
# Now add the region that was extracted here:
prog.add(CommentGen(prog, ""))
prog.add(CommentGen(prog, " RegionStart"))
# For the driver we have to re-create the code of the
# instrumented region, but in this stand-alone driver the
# arguments are not dl_esm_inf fields anymore, but simple arrays.
# Similarly, for properties we cannot use e.g. 'fld%grid%dx'
# anymore, we have to use e.g. a local variable 'dx' that has
# been created. Since we are using the existing way of creating
# the code for the instrumented region, we need to modify how
# these variables are created. We do this by temporarily
# modifying the properties in the config file.
api_config = Config.get().api_conf("gocean1.0")
all_props = api_config.grid_properties
# Keep a copy of the original values, so we can restore
# them later
orig_props = dict(all_props)
# 1) A grid property is defined like "{0}%grid%dx". This is
# changed to be just 'dx', i.e. the final component of
# the current value (but we also take renaming into account,
# so 'dx' might become 'dx_0').
# If a property is not used, it doesn't matter if we modify
# its definition, so we just change all properties.
for name, prop in all_props.items():
last_percent = prop.fortran.rfind("%")
if last_percent > -1:
# Get the last field name, which will be the
# local variable name
local_name = prop.fortran[last_percent+1:]
unique_name = rename_variable.get(local_name, local_name)
all_props[name] = GOceanConfig.make_property(
unique_name, prop.type, prop.intrinsic_type)
# 2) The property 'grid_data' is a reference to the data on the
# grid (i.e. the actual field) , and it is defined as "{0}%data".
# This just becomes {0} ('a_fld%data' in the original program
# becomes just 'a_fld', and 'a_fld' is declared to be a plain
# Fortran 2d-array)
all_props["go_grid_data"] = GOceanConfig.make_property(
"{0}", "array", "real")
# Each kernel caches the argument code, so we also
# need to clear this cached data to make sure the new
# value for "go_grid_data" is actually used.
from psyclone.psyGen import CodedKern
for kernel in self.psy_data_body.walk(CodedKern):
kernel.clear_cached_data()
# Recreate the instrumented region. Due to the changes in the
# config files, fields and properties will now become local
# plain arrays and variables:
for child in self.psy_data_body:
child.gen_code(prog)
# Now reset all properties back to the original values:
for name in all_props.keys():
all_props[name] = orig_props[name]
prog.add(CommentGen(prog, " RegionEnd"))
prog.add(CommentGen(prog, ""))
for var_name in output_list:
prog.add(CommentGen(prog, " Check {0}".format(var_name)))
code = str(module.root)
with open("driver-{0}-{1}.f90".
format(module_name, region_name), "w") as out:
out.write(code)
def gen_code(self, parent):
''' Generates GOcean specific invocation code (the subroutine called
by the associated invoke call in the algorithm layer). This
consists of the PSy invocation subroutine and the declaration of
its arguments.'''
from psyclone.f2pygen import SubroutineGen, DeclGen, TypeDeclGen, \
CommentGen, AssignGen
# create the subroutine
invoke_sub = SubroutineGen(parent,
name=self.name,
args=self.psy_unique_var_names)
parent.add(invoke_sub)
# add declarations for the variables holding the upper bounds
# of loops in i and j
if self.schedule.const_loop_bounds:
invoke_sub.add(
DeclGen(invoke_sub,
datatype="INTEGER",
entity_decls=[
self.schedule.iloop_stop, self.schedule.jloop_stop
]))
# Generate the code body of this subroutine
self.schedule.gen_code(invoke_sub)
# add the subroutine argument declarations for fields
if len(self.unique_args_arrays) > 0:
my_decl_arrays = TypeDeclGen(invoke_sub,
datatype="r2d_field",
intent="inout",
entity_decls=self.unique_args_arrays)
invoke_sub.add(my_decl_arrays)
# add the subroutine argument declarations for real scalars
if len(self.unique_args_rscalars) > 0:
my_decl_rscalars = DeclGen(invoke_sub,
datatype="REAL",
intent="inout",
kind="wp",
entity_decls=self.unique_args_rscalars)
invoke_sub.add(my_decl_rscalars)
# add the subroutine argument declarations for integer scalars
if len(self.unique_args_iscalars) > 0:
my_decl_iscalars = DeclGen(invoke_sub,
datatype="INTEGER",
intent="inout",
entity_decls=self.unique_args_iscalars)
invoke_sub.add(my_decl_iscalars)
if self._schedule.const_loop_bounds and \
len(self.unique_args_arrays) > 0:
# Look-up the loop bounds using the first field object in the
# list
sim_domain = self.unique_args_arrays[0] +\
"%grid%simulation_domain%"
position = invoke_sub.last_declaration()
invoke_sub.add(CommentGen(invoke_sub, ""),
position=["after", position])
invoke_sub.add(AssignGen(invoke_sub,
lhs=self.schedule.jloop_stop,
rhs=sim_domain + "ystop"),
position=["after", position])
invoke_sub.add(AssignGen(invoke_sub,
lhs=self.schedule.iloop_stop,
rhs=sim_domain + "xstop"),
position=["after", position])
invoke_sub.add(CommentGen(invoke_sub, " Look-up loop bounds"),
position=["after", position])
invoke_sub.add(CommentGen(invoke_sub, ""),
position=["after", position])