def test_select_expression(self):
expr = expression_factory(
operators.TERNARY_SELECT_OP,
expression_factory(operators.LESS_OP, self.x, self.i3),
expression_factory(operators.ADD_OP, self.y, self.i1),
expression_factory(operators.MULTIPLY_OP, self.y, self.i2))
self.assertEqual(expr_parse('x < 3 ? y + 1 : y * 2'), expr)
def test_simple_dag_latency(self):
_ = tuple()
dummy_error = ErrorSemantics(1)
w = Variable('w', real_type)
z = Variable('z', real_type)
lw = Label(w, dummy_error, _)
lx = Label(self.x, dummy_error, _)
ly = Label(self.y, dummy_error, _)
lz = Label(z, dummy_error, _)
expr_1 = expression_factory(operators.MULTIPLY_OP, lw, lx)
expr_2 = expression_factory(operators.ADD_OP, ly, lz)
label_1 = Label(expr_1, dummy_error, _)
label_2 = Label(expr_2, dummy_error, _)
expr_3 = expression_factory(operators.SUBTRACT_OP, label_1, label_2)
label_3 = Label(expr_3, dummy_error, _)
env = {
self.x: label_3,
self.y: label_1,
label_1: expr_1,
label_2: expr_2,
label_3: expr_3,
lw: w,
lx: self.x,
ly: self.y,
lz: z,
}
graph = SequentialLatencyDependenceGraph(env, [self.x, self.y])
latency = graph.latency()
expect_latency = LATENCY_TABLE[real_type, operators.ADD_OP]
expect_latency += LATENCY_TABLE[real_type, operators.SUBTRACT_OP]
self.assertEqual(latency, expect_latency)
def test_for_statement(self):
bool_expr = expression_factory(operators.LESS_OP, self.x, self.i3)
init_flow = AssignFlow(self.x, self.i1)
incr_flow = AssignFlow(
self.x, expression_factory(operators.ADD_OP, self.x, self.i1))
assign_flow = AssignFlow(self.y, self.x)
flow = ForFlow(init_flow, bool_expr, incr_flow, assign_flow)
parsed_flow = self.stmt_parse('for (x = 1; x < 3; x = x + 1) {y = x;}')
self.assertEqual(parsed_flow, flow)
def test_compound_boolean_expression(self):
bool_expr_1 = expression_factory(
operators.UNARY_NEGATION_OP,
expression_factory(operators.LESS_OP, self.x, self.i3))
bool_expr_2 = expression_factory(operators.NOT_EQUAL_OP, self.y,
self.i1)
bool_expr = expression_factory(operators.AND_OP, bool_expr_1,
bool_expr_2)
self.assertEqual(expr_parse('not x < 3 and y != 1'), bool_expr)
def test_operator_precedence(self):
neg_y = expression_factory(operators.UNARY_SUBTRACT_OP, self.y)
expr = expression_factory(
operators.ADD_OP, self.x,
expression_factory(operators.MULTIPLY_OP, neg_y, self.z))
self.assertEqual(expr_parse('x + -y * z'), expr)
expr = expression_factory(
operators.MULTIPLY_OP,
expression_factory(operators.ADD_OP, self.x, neg_y), self.z)
self.assertEqual(expr_parse('(x + -y) * z'), expr)
def test_multi_dim_coupled_subscripts_dependence(self):
"""
for (x in 0...9) { a[x + 1, x + 1] = a[x, x]; }
"""
expr_1 = expression_factory(
operators.ADD_OP, self.x, IntegerInterval(1))
expr_2 = expression_factory(
operators.ADD_OP, self.x, IntegerInterval(1))
source = Subscript(expr_1, expr_2)
sink = Subscript(self.x, self.x)
dist_vect = dependence_vector([self.x], [self.sx], source, sink)
self.assertEqual(dist_vect, (1, ))
def test_multi_dim_coupled_subscripts_independence(self):
"""
for (x in 0...9) { a[x + 1, x + 2] = a[x, x]; }
"""
expr_1 = expression_factory(
operators.ADD_OP, self.x, IntegerInterval(1))
expr_2 = expression_factory(
operators.ADD_OP, self.x, IntegerInterval(2))
source = Subscript(expr_1, expr_2)
sink = Subscript(self.x, self.x)
self.assertRaises(
ISLIndependenceException, dependence_vector,
[self.x], [self.sx], source, sink)
def test_simple_independence(self):
source = Subscript(
expression_factory(operators.ADD_OP, self.x, IntegerInterval(20)))
sink = Subscript(self.x)
self.assertRaises(
ISLIndependenceException, dependence_vector,
[self.x], [self.sx], source, sink)
def test_if_statement(self):
bool_expr = expression_factory(operators.LESS_OP, self.x, self.i3)
assign_flow = AssignFlow(self.y, self.x)
flow = IfFlow(bool_expr, assign_flow, SkipFlow())
self.assertEqual(self.stmt_parse('if (x < 3) {y = x;}'), flow)
self.assertEqual(self.stmt_parse('if (x < 3) {y = x;} else {skip;}'),
flow)
def test_simple_subscripts(self):
source = Subscript(
expression_factory(operators.ADD_OP, self.x, IntegerInterval(1)))
sink = Subscript(self.x)
dist_vect = dependence_vector([self.x], [self.sx], source, sink)
self.assertEqual(dist_vect, (1, ))
dist = dependence_distance(dist_vect, [self.sx])
self.assertEqual(dist, 1)
def visit_variable_with_subscript(self, node, children):
var, _1, subscript, _2 = children
dtype = var.dtype
if dtype is not auto_type and len(dtype.shape) != len(subscript):
raise ArrayDimensionError(
'Variable {} is a {}-dimensional array of type {}, '
'but subscript [{}] is {}-dimensional.'.format(
var, len(dtype.shape), dtype,
', '.join(str(s) for s in subscript), len(subscript)))
return expression_factory(operators.INDEX_ACCESS_OP, var, subscript)
def test_multi_dim_subscripts(self):
"""
Test case::
for (x in 0...9) {
for (y in 1...10) {
a[x + 2, y] = ... a[x, y - 1] ...
}
}
"""
expr = expression_factory(operators.ADD_OP, self.x, IntegerInterval(2))
source = Subscript(expr, self.y)
expr = expression_factory(
operators.SUBTRACT_OP, self.y, IntegerInterval(1))
sink = Subscript(self.x, expr)
iter_slices = [self.sx, self.sy]
dist_vect = dependence_vector(
[self.x, self.y], iter_slices, source, sink)
self.assertEqual(dist_vect, (2, 1))
dist = dependence_distance(dist_vect, iter_slices)
self.assertEqual(dist, 21)
def test_function(self):
expr = expression_factory(
operators.ADD_OP,
expression_factory(operators.ADD_OP, self.x, self.y), self.z)
body = CompositionalFlow([
AssignFlow(self.z, expr),
ReturnFlow([self.z]),
])
flow = FunctionFlow(Variable('main', function_type), [
(self.x, self.i1),
(self.y, ErrorSemantics([3.0, 4.0])),
(self.z, ErrorSemantics([5, 6], [0, 0])),
], body)
prog = """
def main(int x=1, real y=[3.0, 4.0], real z=[5.0, 6.0][0, 0]) {
z = x + y + z;
return z;
}
"""
parsed_flow = parse(prog)
self.assertEqual(flow, parsed_flow)
def expand_expr(expr, meta_state):
if is_expression(expr):
args = [expand_expr(a, meta_state) for a in expr.args]
return expression_factory(expr.op, *args)
if is_variable(expr):
try:
new_expr = meta_state[expr]
except KeyError:
raise KeyError(
'Cannot expand the expression {expr}, missing variable in '
'{state}'.format(expr=expr, state=meta_state))
return new_expr
if is_numeral(expr):
return expr
raise TypeError(
'Do not know how to expand the expression {expr} with expression '
'state {state}.'.format(expr=expr, state=meta_state))
def test_variable_subscript(self):
expr = expression_factory(operators.INDEX_ACCESS_OP, self.x,
Subscript(self.i1))
self.assertEqual(expr_parse('x[1]'), expr)
expr = expression_factory(
operators.INDEX_ACCESS_OP, self.x,
Subscript(expression_factory(operators.ADD_OP, self.y, self.i1)))
self.assertEqual(expr_parse('x[y + 1]'), expr)
expr = expression_factory(operators.INDEX_ACCESS_OP, self.x,
Subscript(self.y, self.i1))
self.assertEqual(expr_parse('x[y, 1]'), expr)
expr = expression_factory(
operators.INDEX_ACCESS_OP, self.x,
Subscript(
expression_factory(operators.INDEX_ACCESS_OP, self.y,
Subscript(self.i1))))
self.assertEqual(expr_parse('x[y[1]]'), expr)
def test_assign_statement(self):
expr = expression_factory(operators.ADD_OP, self.y, self.i1)
flow = AssignFlow(self.x, expr)
self.assertEqual(self.stmt_parse('x = y + 1;'), flow)
def visit_binary_bool_expr(self, node, children):
a1, op, a2 = children
return expression_factory(op, a1, a2)
def visit_unary_bool_expr(self, node, children):
op, a = children
return expression_factory(op, a)
def visit_select(self, node, children):
bool_expr, q_lit, true_expr, c_lit, false_expr = children
return expression_factory(operators.TERNARY_SELECT_OP, bool_expr,
true_expr, false_expr)
def visit_unary_expr(self, node, children):
op, atom = children
if op == operators.SUBTRACT_OP:
op = operators.UNARY_SUBTRACT_OP
return expression_factory(op, atom)
def test_while_statement(self):
bool_expr = expression_factory(operators.LESS_OP, self.x, self.i3)
assign_flow = AssignFlow(self.y, self.x)
flow = WhileFlow(bool_expr, assign_flow)
self.assertEqual(self.stmt_parse('while (x < 3) {y = x;}'), flow)
def _visit_concat_expr(self, node, children):
expr, expr_list = children
for each_expr in expr_list:
each_op, each_factor = each_expr
expr = expression_factory(each_op, expr, each_factor)
return expr