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_scalartype_immutable(): '''Test that the scalartype attributes can't be modified''' data_type = ScalarType(ScalarType.Intrinsic.REAL, 4) with pytest.raises(AttributeError): data_type.intrinsic = ScalarType.Intrinsic.INTEGER with pytest.raises(AttributeError): data_type.precision = 8
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_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_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_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_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_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_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_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_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))
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
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 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 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"