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