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
# create the subroutine
invoke_sub = SubroutineGen(parent, name=self.name,
args=self.psy_unique_var_names)
parent.add(invoke_sub)
self.schedule.gen_code(invoke_sub)
# add the subroutine argument declarations for arrays
if len(self.unique_args_arrays) > 0:
my_decl_arrays = DeclGen(invoke_sub, datatype="REAL",
intent="inout", kind="go_wp",
entity_decls=self.unique_args_arrays,
dimension=":,:")
invoke_sub.add(my_decl_arrays)
# add the subroutine argument declarations for scalars
if len(self.unique_args_scalars) > 0:
my_decl_scalars = \
TypeDeclGen(invoke_sub,
datatype="scalar_field_type",
entity_decls=self.unique_args_scalars,
intent="inout")
invoke_sub.add(my_decl_scalars)
def test_typedeclgen_missing_names():
''' Check that we raise an error if we attempt to create TypeDeclGen
without naming the variables '''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
with pytest.raises(RuntimeError) as err:
_ = TypeDeclGen(sub, datatype="my_type")
assert ("Cannot create a declaration of a derived-type variable "
"without specifying" in str(err))
def test_typedeclgen_names():
''' Check that the names method of TypeDeclGen works as expected '''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
dgen = TypeDeclGen(sub, datatype="my_type", entity_decls=["type1"])
sub.add(dgen)
names = dgen.names
assert len(names) == 1
assert names[0] == "type1"
def test_imp_none_in_module_with_decs():
''' test that implicit none is added before any declaration
statements in a module 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(ImplicitNoneGen(module))
in_idx = line_number(module.root, "IMPLICIT NONE")
assert in_idx == 1
def test_typedeclgen_multiple_use():
'''Check that we correctly handle the case where data of the same type
has already been declared. '''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
# first declaration
datanames = ["type1"]
sub.add(TypeDeclGen(sub, datatype="my_type", entity_decls=datanames))
gen = str(sub.root)
# second declaration
datanames = ["type1", "type2"]
sub.add(TypeDeclGen(sub, datatype="my_type", entity_decls=datanames))
gen = str(sub.root)
print gen
expected = (" TYPE(my_type) type2\n" " TYPE(my_type) type1")
assert expected in gen
# check input data is not modified
assert datanames == ["type1", "type2"]
def test_imp_none_in_subroutine_with_use_and_decs():
''' test that implicit none is added after any use statements
and before any declarations in a subroutine when auto (the
default) is used for insertion'''
module = ModuleGen(name="testmodule")
sub = SubroutineGen(module, name="testsubroutine")
module.add(sub)
sub.add(DeclGen(sub, datatype="integer", entity_decls=["var1"]))
sub.add(TypeDeclGen(sub, datatype="my_type", entity_decls=["type1"]))
sub.add(UseGen(sub, "fred"))
sub.add(ImplicitNoneGen(sub))
in_idx = line_number(sub.root, "IMPLICIT NONE")
assert in_idx == 2
def test_decl_no_replication_types():
'''Check that the same array variable will only get declared once in
a module and a subroutine'''
variable_name = "arg_name"
datatype = "field_type"
module = ModuleGen(name="testmodule")
module.add(
TypeDeclGen(module, datatype=datatype, entity_decls=[variable_name]))
module.add(
TypeDeclGen(module, datatype=datatype, entity_decls=[variable_name]))
subroutine = SubroutineGen(module, name="testsubroutine")
module.add(subroutine)
subroutine.add(
TypeDeclGen(subroutine,
datatype=datatype,
entity_decls=[variable_name]))
subroutine.add(
TypeDeclGen(subroutine,
datatype=datatype,
entity_decls=[variable_name]))
generated_code = str(module.root)
assert generated_code.count(variable_name) == 2
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 gen_code(self, parent):
# pylint: disable=arguments-differ
'''Creates the profile start and end calls, surrounding the children
of this node.
:param parent: the parent of this node.
:type parent: :py:class:`psyclone.psyGen.Node`
'''
if self._module_name is None or self._region_name is None:
# Find the first kernel and use its name. In an untransformed
# Schedule there should be only one kernel, but if Profile is
# invoked after e.g. a loop merge more kernels might be there.
region_name = "unknown-kernel"
module_name = "unknown-module"
for kernel in self.walk(Kern):
region_name = kernel.name
module_name = kernel.module_name
break
if self._region_name is None:
self._region_name = Profiler.create_unique_region(region_name)
if self._module_name is None:
self._module_name = module_name
# Note that adding a use statement makes sure it is only
# added once, so we don't need to test this here!
use = UseGen(parent,
self.fortran_module,
only=True,
funcnames=["ProfileData, ProfileStart, ProfileEnd"])
parent.add(use)
prof_var_decl = TypeDeclGen(parent,
datatype="ProfileData",
entity_decls=[self._var_name],
save=True)
parent.add(prof_var_decl)
prof_start = CallGen(parent, "ProfileStart", [
"\"{0}\"".format(self._module_name), "\"{0}\"".format(
self._region_name), self._var_name
])
parent.add(prof_start)
for child in self.children:
child.gen_code(parent)
prof_end = CallGen(parent, "ProfileEnd", [self._var_name])
parent.add(prof_end)
def gen_code(self, parent):
''' Generates Dynamo 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, TypeDeclGen
# create the subroutine
invoke_sub = SubroutineGen(parent,
name=self.name,
args=self.psy_unique_var_names)
self.schedule.gen_code(invoke_sub)
parent.add(invoke_sub)
# add the subroutine argument declarations
my_typedecl = TypeDeclGen(invoke_sub,
datatype="field_type",
entity_decls=self.psy_unique_var_names,
intent="inout")
invoke_sub.add(my_typedecl)
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, options=None):
# pylint: disable=arguments-differ, too-many-branches
'''Creates the PSyData code before and after the children
of this node.
:param parent: the parent of this node in the f2pygen AST.
:type parent: :py:class:`psyclone.f2pygen.BaseGen`
:param options: a dictionary with options for transformations.
:type options: dictionary of string:values or None
:param options["pre_var_list"]: a list of variables to be extracted \
before the first child.
:type options["pre_var_list"]: list of str
:param options["post_var_list"]: a list of variables to be extracted \
after the last child.
:type options["post_var_list"]: list of str
:param str options["pre_var_postfix"]: an optional postfix that will \
be added to each variable name in the pre_var_list.
:param str options["post_var_postfix"]: an optional postfix that will \
be added to each variable name in the post_var_list.
'''
# Avoid circular dependency
# pylint: disable=import-outside-toplevel
from psyclone.psyGen import Kern, InvokeSchedule
# TODO: #415 Support different classes of PSyData calls.
invoke = self.ancestor(InvokeSchedule).invoke
module_name = self._module_name
if module_name is None:
# The user has not supplied a module (location) name so
# return the psy-layer module name as this will be unique
# for each PSyclone algorithm file.
module_name = invoke.invokes.psy.name
region_name = self._region_name
if region_name is None:
# The user has not supplied a region name (to identify
# this particular invoke region). Use the invoke name as a
# starting point.
region_name = invoke.name
kerns = self.walk(Kern)
if len(kerns) == 1:
# This PSyData region only has one kernel within it,
# so append the kernel name.
region_name += ":{0}".format(kerns[0].name)
# Add a region index to ensure uniqueness when there are
# multiple regions in an invoke.
psy_data_nodes = self.root.walk(PSyDataNode)
idx = psy_data_nodes.index(self)
region_name += ":r{0}".format(idx)
if not options:
options = {}
pre_variable_list = options.get("pre_var_list", [])
post_variable_list = options.get("post_var_list", [])
pre_suffix = options.get("pre_var_postfix", "")
post_suffix = options.get("post_var_postfix", "")
# Note that adding a use statement makes sure it is only
# added once, so we don't need to test this here!
use = UseGen(parent, self.fortran_module, only=True,
funcnames=[sym.name for sym in self.imported_symbols])
parent.add(use)
var_decl = TypeDeclGen(parent,
datatype=self.type_name,
entity_decls=[self._var_name],
save=True, target=True)
parent.add(var_decl)
self._add_call("PreStart", parent,
["\"{0}\"".format(module_name),
"\"{0}\"".format(region_name),
len(pre_variable_list),
len(post_variable_list)])
self.set_region_identifier(module_name, region_name)
has_var = pre_variable_list or post_variable_list
# Each variable name can be given a suffix. The reason for
# this feature is that a library might have to distinguish if
# a variable is both in the pre- and post-variable list.
# Consider a NetCDF file that is supposed to store a
# variable that is read (i.e. it is in the pre-variable
# list) and written (it is also in the post-variable
# list). Since a NetCDF file uses the variable name as a key,
# there must be a way to distinguish these two variables.
# The application could for example give all variables in
# the post-variable list a suffix like "_post" to create
# a different key in the NetCDF file, allowing it to store
# values of a variable "A" as "A" in the pre-variable list,
# and store the modified value of "A" later as "A_post".
if has_var:
for var_name in pre_variable_list:
self._add_call("PreDeclareVariable", parent,
["\"{0}{1}\"".format(var_name, pre_suffix),
var_name])
for var_name in post_variable_list:
self._add_call("PreDeclareVariable", parent,
["\"{0}{1}\"".format(var_name, post_suffix),
var_name])
self._add_call("PreEndDeclaration", parent)
for var_name in pre_variable_list:
self._add_call("ProvideVariable", parent,
["\"{0}{1}\"".format(var_name, pre_suffix),
var_name])
self._add_call("PreEnd", parent)
for child in self.psy_data_body:
child.gen_code(parent)
if has_var:
# Only add PostStart() if there is at least one variable.
self._add_call("PostStart", parent)
for var_name in post_variable_list:
self._add_call("ProvideVariable", parent,
["\"{0}{1}\"".format(var_name, post_suffix),
var_name])
self._add_call("PostEnd", parent)
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])
