def test_scalartype_invalid_precision_datasymbol():
'''Test that the ScalarType class raises an exception when an invalid
precision symbol is provided (it must be a scalar integer or
deferred).
'''
# Create an r_def precision symbol with a constant value of 8
data_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
precision_symbol = DataSymbol("r_def", data_type)
with pytest.raises(ValueError) as excinfo:
_ = ScalarType(ScalarType.Intrinsic.REAL, precision_symbol)
assert ("A DataSymbol representing the precision of another DataSymbol "
"must be of either 'deferred' or scalar, integer type but got: "
"r_def: <Scalar<REAL, 4>, Local>" in str(excinfo.value))
def test_scalartype_datasymbol_precision(intrinsic):
'''Test that the ScalarType class can be created successfully for all
supported ScalarType intrinsics and the precision specified by another
symbol.
'''
# Create an r_def precision symbol with a constant value of 8
data_type = ScalarType(ScalarType.Intrinsic.INTEGER,
ScalarType.Precision.UNDEFINED)
precision_symbol = DataSymbol("r_def", data_type, constant_value=8)
# Set the precision of our ScalarType to be the precision symbol
scalar_type = ScalarType(intrinsic, precision_symbol)
assert isinstance(scalar_type, ScalarType)
assert scalar_type.intrinsic == intrinsic
assert scalar_type.precision is precision_symbol
def test_arraytype():
'''Test that the ArrayType class __init__ works as expected. Test the
different dimension datatypes that are supported.'''
scalar_type = ScalarType(ScalarType.Intrinsic.INTEGER, 4)
data_symbol = DataSymbol("var", scalar_type, constant_value=30)
one = Literal("1", scalar_type)
var_plus_1 = BinaryOperation.create(
BinaryOperation.Operator.ADD, Reference(data_symbol), one)
literal = Literal("20", scalar_type)
array_type = ArrayType(
scalar_type, [10, literal, var_plus_1, Reference(data_symbol),
ArrayType.Extent.DEFERRED, ArrayType.Extent.ATTRIBUTE])
assert isinstance(array_type, ArrayType)
assert len(array_type.shape) == 6
# Provided as an int but stored as a Literal
shape0 = array_type.shape[0]
assert isinstance(shape0, Literal)
assert shape0.value == "10"
assert shape0.datatype.intrinsic == ScalarType.Intrinsic.INTEGER
assert shape0.datatype.precision == ScalarType.Precision.UNDEFINED
# Provided and stored as a Literal (DataNode)
assert array_type.shape[1] is literal
# Provided and stored as an Operator (DataNode)
assert array_type.shape[2] is var_plus_1
# Provided and stored as a Reference to a DataSymbol
assert isinstance(array_type.shape[3], Reference)
assert array_type.shape[3].symbol is data_symbol
# Provided and stored as a deferred extent
assert array_type.shape[4] == ArrayType.Extent.DEFERRED
# Provided as an attribute extent
assert array_type.shape[5] == ArrayType.Extent.ATTRIBUTE
def test_handling_literal_precision_1(value, dprecision, intrinsic):
'''Check that the fparser2 frontend can handle literals with a
specified precision kind symbol.
'''
if intrinsic == ScalarType.Intrinsic.CHARACTER:
code = "x={0}_{1}".format(dprecision, value)
else:
code = "x={0}_{1}".format(value, dprecision)
reader = FortranStringReader(code)
astmt = Fortran2003.Assignment_Stmt(reader)
fake_parent = Schedule()
# Ensure the symbol table has an entry for "x"
fake_parent.symbol_table.add(
DataSymbol("x", ScalarType(ScalarType.Intrinsic.INTEGER, 4)))
processor = Fparser2Reader()
processor.process_nodes(fake_parent, [astmt])
assert not fake_parent.walk(CodeBlock)
literal = fake_parent.children[0].children[1]
assert isinstance(literal, Literal)
assert literal.datatype.intrinsic == intrinsic
if intrinsic == ScalarType.Intrinsic.BOOLEAN:
assert ".{0}.".format(literal.value) == value.lower()
else:
assert literal.value == value
assert isinstance(literal.datatype.precision, DataSymbol)
assert literal.datatype.precision.name == dprecision
assert isinstance(literal.datatype.precision.datatype, ScalarType)
assert (literal.datatype.precision.datatype.intrinsic ==
ScalarType.Intrinsic.INTEGER)
def test_arraytype():
'''Test that the ArrayType class __init__ works as expected.'''
datatype = ScalarType(ScalarType.Intrinsic.INTEGER, 4)
shape = [10, 10]
array_type = ArrayType(datatype, shape)
assert isinstance(array_type, ArrayType)
assert array_type.shape == shape
assert array_type._datatype == datatype
def test_scalartype_invalid_precision_int_value():
'''Test that the ScalarType class raises an exception when an invalid
integer precision value is provided.
'''
with pytest.raises(ValueError) as excinfo:
_ = ScalarType(ScalarType.Intrinsic.INTEGER, 0)
assert ("The precision of a DataSymbol when specified as an integer "
"number of bytes must be > 0 but found '0'." in str(excinfo.value))
def test_scalartype_invalid_intrinsic_type():
'''Test that the ScalarType class raises an exception when an invalid
intrinsic type is provided.
'''
with pytest.raises(TypeError) as excinfo:
_ = ScalarType(None, None)
assert ("ScalarType expected 'intrinsic' argument to be of type "
"ScalarType.Intrinsic but found 'NoneType'." in str(excinfo.value))
def test_scalartype_int_precision(intrinsic, precision):
'''Test that the ScalarType class can be created successfully for all
supported ScalarType intrinsics and a set of valid integer precisions.
'''
scalar_type = ScalarType(intrinsic, precision)
assert isinstance(scalar_type, ScalarType)
assert scalar_type.intrinsic == intrinsic
assert scalar_type.precision == precision
def test_arraytype_immutable():
'''Test that the scalartype attributes can't be modified'''
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
data_type = ArrayType(scalar_type, [10, 10])
with pytest.raises(AttributeError):
data_type.intrinsic = ScalarType.Intrinsic.INTEGER
with pytest.raises(AttributeError):
data_type.precision = 8
with pytest.raises(AttributeError):
data_type.shape = []
def test_scalartype_invalid_precision_type():
'''Test that the ScalarType class raises an exception when an invalid
precision type is provided.
'''
with pytest.raises(TypeError) as excinfo:
_ = ScalarType(ScalarType.Intrinsic.INTEGER, None)
assert ("ScalarType expected 'precision' argument to be of type int, "
"ScalarType.Precision or DataSymbol, but found 'NoneType'."
in str(excinfo.value))
def test_arraytype_str():
'''Test that the ArrayType class str method works as expected.'''
scalar_type = ScalarType(ScalarType.Intrinsic.INTEGER,
ScalarType.Precision.UNDEFINED)
data_symbol = DataSymbol("var", scalar_type)
data_type = ArrayType(scalar_type, [
10, data_symbol, ArrayType.Extent.DEFERRED, ArrayType.Extent.ATTRIBUTE
])
assert (str(data_type) == "Array<Scalar<INTEGER, UNDEFINED>,"
" shape=[10, var, 'DEFERRED', 'ATTRIBUTE']>")
def test_arraytype_invalid_shape():
'''Test that the ArrayType class raises an exception when the shape
argument is the wrong type.
'''
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
with pytest.raises(TypeError) as excinfo:
_ = ArrayType(scalar_type, None)
assert ("ArrayType 'shape' must be of type list but "
"found 'NoneType'." in str(excinfo.value))
def test_datasymbol_copy():
'''Test that the DataSymbol copy method produces a faithful separate copy
of the original symbol.
'''
array_type = ArrayType(REAL_SINGLE_TYPE, [1, 2])
symbol = DataSymbol("myname",
array_type,
constant_value=None,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE))
new_symbol = symbol.copy()
# Check the new symbol has the same properties as the original
assert symbol.name == new_symbol.name
assert symbol.datatype == new_symbol.datatype
assert symbol.shape == new_symbol.shape
assert symbol.constant_value == new_symbol.constant_value
assert symbol.interface == new_symbol.interface
# Change the properties of the new symbol and check the original
# is not affected. Can't check constant_value yet as we have a
# shape value
new_symbol._name = "new"
new_symbol.datatype = ArrayType(
ScalarType(ScalarType.Intrinsic.INTEGER, ScalarType.Precision.DOUBLE),
[3, 4])
new_symbol._interface = LocalInterface()
assert symbol.name == "myname"
assert symbol.datatype.intrinsic == ScalarType.Intrinsic.REAL
assert symbol.datatype.precision == ScalarType.Precision.SINGLE
assert len(symbol.shape) == 2
assert isinstance(symbol.shape[0], Literal)
assert symbol.shape[0].value == "1"
assert symbol.shape[0].datatype.intrinsic == ScalarType.Intrinsic.INTEGER
assert symbol.shape[0].datatype.precision == ScalarType.Precision.UNDEFINED
assert isinstance(symbol.shape[1], Literal)
assert symbol.shape[1].value == "2"
assert symbol.shape[1].datatype.intrinsic == ScalarType.Intrinsic.INTEGER
assert symbol.shape[1].datatype.precision == ScalarType.Precision.UNDEFINED
assert not symbol.constant_value
# Now check constant_value
new_symbol.constant_value = 3
assert isinstance(symbol.shape[0], Literal)
assert symbol.shape[0].value == "1"
assert symbol.shape[0].datatype.intrinsic == ScalarType.Intrinsic.INTEGER
assert symbol.shape[0].datatype.precision == ScalarType.Precision.UNDEFINED
assert isinstance(symbol.shape[1], Literal)
assert symbol.shape[1].value == "2"
assert symbol.shape[1].datatype.intrinsic == ScalarType.Intrinsic.INTEGER
assert symbol.shape[1].datatype.precision == ScalarType.Precision.UNDEFINED
assert not symbol.constant_value
def test_arraytype_str():
'''Test that the ArrayType class str method works as expected.'''
scalar_type = ScalarType(ScalarType.Intrinsic.INTEGER,
ScalarType.Precision.UNDEFINED)
data_symbol = DataSymbol("var", scalar_type, constant_value=20)
data_type = ArrayType(scalar_type, [10, Reference(data_symbol),
ArrayType.Extent.DEFERRED,
ArrayType.Extent.ATTRIBUTE])
assert (str(data_type) == "Array<Scalar<INTEGER, UNDEFINED>,"
" shape=[Literal[value:'10', Scalar<INTEGER, UNDEFINED>], "
"Reference[name:'var'], 'DEFERRED', 'ATTRIBUTE']>")
def test_arraytype_invalid_shape_dimension_2():
'''Test that the ArrayType class raises an exception when one of the
dimensions of the shape list argument is not a datasymbol, datanode,
integer or ArrayType.Extent type.
'''
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
with pytest.raises(TypeError) as excinfo:
_ = ArrayType(scalar_type, [None])
assert ("DataSymbol shape list elements can only be 'int', "
"ArrayType.Extent or 'DataNode' but found 'NoneType'."
in str(excinfo.value))
def test_datasymbol_initialisation():
'''Test that a DataSymbol instance can be created when valid arguments are
given, otherwise raise relevant exceptions.'''
# Test with valid arguments
assert isinstance(DataSymbol('a', REAL_SINGLE_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', REAL_DOUBLE_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', REAL4_TYPE), DataSymbol)
kind = DataSymbol('r_def', INTEGER_SINGLE_TYPE)
real_kind_type = ScalarType(ScalarType.Intrinsic.REAL, kind)
assert isinstance(DataSymbol('a', real_kind_type),
DataSymbol)
# real constants are not currently supported
assert isinstance(DataSymbol('a', INTEGER_SINGLE_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', INTEGER_DOUBLE_TYPE, constant_value=0),
DataSymbol)
assert isinstance(DataSymbol('a', INTEGER4_TYPE),
DataSymbol)
assert isinstance(DataSymbol('a', CHARACTER_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', CHARACTER_TYPE,
constant_value="hello"), DataSymbol)
assert isinstance(DataSymbol('a', BOOLEAN_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', BOOLEAN_TYPE,
constant_value=False),
DataSymbol)
array_type = ArrayType(REAL_SINGLE_TYPE, [ArrayType.Extent.ATTRIBUTE])
assert isinstance(DataSymbol('a', array_type), DataSymbol)
array_type = ArrayType(REAL_SINGLE_TYPE, [3])
assert isinstance(DataSymbol('a', array_type), DataSymbol)
array_type = ArrayType(REAL_SINGLE_TYPE, [3, ArrayType.Extent.ATTRIBUTE])
assert isinstance(DataSymbol('a', array_type), DataSymbol)
assert isinstance(DataSymbol('a', REAL_SINGLE_TYPE), DataSymbol)
assert isinstance(DataSymbol('a', REAL8_TYPE), DataSymbol)
dim = DataSymbol('dim', INTEGER_SINGLE_TYPE,
interface=UnresolvedInterface())
array_type = ArrayType(REAL_SINGLE_TYPE, [Reference(dim)])
assert isinstance(DataSymbol('a', array_type), DataSymbol)
array_type = ArrayType(REAL_SINGLE_TYPE,
[3, Reference(dim), ArrayType.Extent.ATTRIBUTE])
assert isinstance(DataSymbol('a', array_type), DataSymbol)
assert isinstance(
DataSymbol('a', REAL_SINGLE_TYPE,
interface=ArgumentInterface(
ArgumentInterface.Access.READWRITE)), DataSymbol)
assert isinstance(
DataSymbol('a', REAL_SINGLE_TYPE,
visibility=Symbol.Visibility.PRIVATE), DataSymbol)
assert isinstance(DataSymbol('field', DataTypeSymbol("field_type",
DeferredType())),
DataSymbol)
def test_arraytype_invalid_shape_dimension_1():
'''Test that the ArrayType class raises an exception when one of the
dimensions of the shape list argument is a datasymbol but is not a
scalar integer.
'''
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
symbol = DataSymbol("fred", scalar_type)
with pytest.raises(TypeError) as excinfo:
_ = ArrayType(scalar_type, [symbol])
assert ("DataSymbols that are part of another symbol shape can only be "
"scalar integers, but found 'fred: <Scalar<REAL, 4>, Local>'."
in str(excinfo.value))
def test_arraytype_str_invalid():
'''Test that the ArrayType class str method raises an exception if an
unsupported dimension type is found.
'''
scalar_type = ScalarType(ScalarType.Intrinsic.INTEGER, 4)
array_type = ArrayType(scalar_type, [10])
# Make one of the array dimensions an unsupported type
array_type._shape = [None]
with pytest.raises(InternalError) as excinfo:
_ = str(array_type)
assert ("PSyclone internal error: ArrayType shape list elements can only "
"be 'DataNode', or 'ArrayType.Extent', but found 'NoneType'."
in str(excinfo.value))
def test_arraytype_invalid_shape_dimension_1():
'''Test that the ArrayType class raises an exception when one of the
dimensions of the shape list argument is a datasymbol but is not a
scalar integer.
'''
scalar_type = ScalarType(ScalarType.Intrinsic.REAL, 4)
symbol = DataSymbol("fred", scalar_type, constant_value=3.0)
with pytest.raises(TypeError) as excinfo:
_ = ArrayType(scalar_type, [Reference(symbol)])
assert (
"If a datasymbol is used as a dimension declaration then it should "
"be a scalar integer or an unknown type, but 'fred' is a "
"'Scalar<REAL, 4>'." in str(excinfo.value))
def test_arraytype_invalid_shape_dimension_3():
'''Test that the ArrayType class raises an exception when one of the
dimensions of the shape list argument is a DataNode that contains
a local datasymbol that does not have a constant value (as this
will not be initialised).
'''
scalar_type = ScalarType(ScalarType.Intrinsic.INTEGER, 4)
data_symbol = DataSymbol("var", scalar_type)
one = Literal("1", scalar_type)
var_plus_1 = BinaryOperation.create(
BinaryOperation.Operator.ADD, Reference(data_symbol), one)
with pytest.raises(TypeError) as info:
_ = ArrayType(scalar_type, [var_plus_1])
assert ("If a local datasymbol is used as part of a dimension "
"declaration then it should be a constant, but 'var' is "
"not." in str(info.value))
def test_scalartype_str():
'''Test that the ScalarType class str method works as expected.'''
data_type = ScalarType(ScalarType.Intrinsic.BOOLEAN,
ScalarType.Precision.UNDEFINED)
assert str(data_type) == "Scalar<BOOLEAN, UNDEFINED>"
def test_literal_value():
'''Test the value property returns the value of the Literal object.'''
integer_type = ScalarType(ScalarType.Intrinsic.INTEGER,
ScalarType.Precision.DOUBLE)
literal = Literal("1", integer_type)
assert literal.value == "1"
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
BinaryOperation, Range
from psyclone.psyir.symbols import DataSymbol, SymbolTable, StructureType, \
ContainerSymbol, ArgumentInterface, ScalarType, ArrayType, TypeSymbol, \
GlobalInterface, INTEGER_TYPE, INTEGER4_TYPE, INTEGER8_TYPE, \
DeferredType, Symbol
from psyclone.psyir.backend.fortran import FortranWriter
# Symbol table for container (container itself created after kernel)
CONTAINER_SYMBOL_TABLE = SymbolTable()
REAL_KIND = CONTAINER_SYMBOL_TABLE.new_symbol(
root_name="RKIND", symbol_type=DataSymbol, datatype=INTEGER_TYPE,
constant_value=8)
# Shorthand for a scalar type with REAL_KIND precision
SCALAR_TYPE = ScalarType(ScalarType.Intrinsic.REAL, REAL_KIND)
# Derived-type definition in container
GRID_TYPE = StructureType.create([
("dx", SCALAR_TYPE, Symbol.Visibility.PUBLIC),
("dy", SCALAR_TYPE, Symbol.Visibility.PUBLIC)])
GRID_TYPE_SYMBOL = TypeSymbol("grid_type", GRID_TYPE)
CONTAINER_SYMBOL_TABLE.add(GRID_TYPE_SYMBOL)
# Kernel symbol table, symbols and scalar datatypes
SYMBOL_TABLE = SymbolTable()
CONT = ContainerSymbol("kernel_mod")
SYMBOL_TABLE.add(CONT)
DTYPE_SYMBOL = TypeSymbol("other_type", DeferredType(),
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