def test_matrix_update(self):
mat = self.matrix.update((1, 2), 1)
self.assertEqual(mat[1, 2], IntegerInterval(1))
mat = self.matrix.update(([1, 2], 1), 1)
val = IntegerInterval([1, 9])
self.assertEqual(mat[1, 1], val)
self.assertEqual(mat[2, 1], val)
def test_matrix_content(self):
intervals = [IntegerInterval(v) for v in self.vector_values]
self.assertListEqual(intervals, list(self.vector))
x_shape, y_shape = self.matrix.shape
for x, y in itertools.product(range(x_shape), range(y_shape)):
val = IntegerInterval(self.matrix_values[x][y])
self.assertEqual(val, self.matrix[x, y])
def test_MetaState(self):
meta_state = MetaState({
self.x: BinaryArithExpr(
operators.ADD_OP, self.x, IntegerInterval(1)),
self.y: BinaryArithExpr(
operators.MULTIPLY_OP, self.x, IntegerInterval(2)),
})
test_state = BoxState(x=[2, 3], y=[2, 4])
state = arith_eval(meta_state, self.state)
self.assertEqual(test_state, state)
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_FixExpr(self):
bool_expr = BinaryBoolExpr(operators.LESS_OP, self.x, self.y)
loop_state = MetaState({
self.x: BinaryArithExpr(
operators.ADD_OP, self.x, IntegerInterval(1)),
self.y: self.y,
})
init_state = MetaState({
self.x: self.x, self.y: self.y,
})
test_expr = FixExpr(bool_expr, loop_state, self.x, init_state)
test_value = IntegerInterval(3)
value = arith_eval(test_expr, self.state)
self.assertEqual(test_value, value)
def test_SelectExpr(self):
test_expr = SelectExpr(
BinaryBoolExpr(operators.LESS_OP, self.x, ErrorSemantics(1.5)),
IntegerInterval(0), self.y)
test_value = IntegerInterval(0)
value = arith_eval(test_expr, self.state)
self.assertEqual(test_value, value)
test_expr = SelectExpr(
BinaryBoolExpr(operators.LESS_OP, self.z, ErrorSemantics(1.5)),
IntegerInterval(0), self.y)
test_value = IntegerInterval([0, 3])
value = arith_eval(test_expr, self.state)
self.assertEqual(test_value, value)
def setUp(self):
self.context = LabelContext('test_context')
mat = IntegerIntervalArray([1, 2, 3, 4])
self.x = Variable('x', int_type)
self.y = Variable('y', int_type)
self.z = Variable('z', IntegerArrayType([4]))
self.state = BoxState({
self.x: [1, 2],
self.y: 3,
self.z: mat,
})
self.x_label = self.context.Label(
self.x, IntegerInterval([1, 2]), None)
self.y_label = self.context.Label(self.y, IntegerInterval(3), None)
self.z_label = self.context.Label(self.z, mat, None)
def bool_expr(self):
expr = BinaryBoolExpr(operators.LESS_OP, self.x, self.y)
label_expr = BinaryBoolExpr(
operators.LESS_OP, self.x_label, self.y_label)
# FIXME bound for bool_expr does not make sense
label = self.context.Label(expr, IntegerInterval([-2, -1]), None)
return label, expr, label_expr
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_UnaryArithExpr(self):
expr = UnaryArithExpr(operators.UNARY_SUBTRACT_OP, self.x)
label_expr = UnaryArithExpr(
operators.UNARY_SUBTRACT_OP, self.x_label)
label = self.context.Label(expr, IntegerInterval([-2, -1]), None)
env = {label: label_expr, self.x_label: self.x}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
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 test_join_and_meet(self):
other_matrix = IntArray([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
join_test_matrix = IntArray(
self._list_elements_to_interval([[[1, 9], [2, 8], [3, 7]],
[[4, 8], [5, 9], [4, 9]],
[[3, 9], [2, 9], [1, 9]]]))
self.assertEqual(self.matrix | other_matrix, join_test_matrix)
bot = IntegerInterval(bottom=True)
meet_test_matrix = IntArray([[bot, bot, 7], [6, 5, bot],
[bot, bot, bot]])
self.assertEqual(self.matrix & other_matrix, meet_test_matrix)
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_simple_loop(self):
program = """
def main(real[30] a) {
for (int i = 1; i < 10; i = i + 1) {
a[i] = a[i - 1] + 1;
}
return a;
}
"""
flow = parse(program)
meta_state = flow_to_meta_state(flow)
fix_expr = meta_state[flow.outputs[0]]
for_loop = ForLoopExtractor(fix_expr)
expect_for_loop = {
'iter_var': self.i,
'start': IntegerInterval(1),
'stop': IntegerInterval(10),
'step': IntegerInterval(1),
'has_inner_loops': False,
}
self.compare(for_loop, expect_for_loop)
def test_BinaryArithExpr(self):
expr = BinaryArithExpr(operators.ADD_OP, self.x, self.y)
label_expr = BinaryArithExpr(
operators.ADD_OP, self.x_label, self.y_label)
label = self.context.Label(expr, IntegerInterval([4, 5]), None)
env = {
label: label_expr,
self.x_label: self.x,
self.y_label: self.y,
}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
def test_FixExpr(self):
init_state = MetaState({self.x: IntegerInterval(0)})
init_label, init_env = self.label(init_state)
invar = BoxState({self.x: IntegerInterval([0, 4])})
end_invar = BoxState({self.x: IntegerInterval([1, 5])})
loop_state = MetaState({
self.x: BinaryArithExpr(
operators.ADD_OP, self.x, IntegerInterval(1)),
})
loop_label, loop_env = self.label(loop_state, invar)
bool_expr = BinaryBoolExpr(
operators.LESS_OP, self.x, IntegerInterval(5))
bool_labsem = self.label(bool_expr, end_invar)
bool_label, _ = bool_labsem
expr = FixExpr(bool_expr, loop_state, self.x, init_state)
bound = IntegerInterval(5)
label = self.context.Label(expr, bound, invar)
label_expr = FixExpr(bool_labsem, loop_env, self.x, init_env)
env = {label: label_expr}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
def test_SelectExpr(self):
bool_label, bool_expr, bool_label_expr = self.bool_expr()
expr = SelectExpr(bool_expr, self.x, self.y)
label_expr = SelectExpr(bool_label, self.x_label, self.y_label)
label = self.context.Label(expr, IntegerInterval([1, 2]), None)
env = {
label: label_expr,
bool_label: bool_label_expr,
self.x_label: self.x,
self.y_label: self.y,
}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
def test_AccessExpr(self):
subscript = Subscript(self.y)
expr = AccessExpr(self.z, subscript)
label_subscript_expr = Subscript(self.y_label)
subscript_label = self.context.Label(
subscript, IntegerIntervalArray([self.state[self.y]]), None)
label_expr = AccessExpr(self.z_label, subscript_label)
label = self.context.Label(expr, IntegerInterval(4), None)
env = {
label: label_expr,
subscript_label: label_subscript_expr,
self.y_label: self.y,
self.z_label: self.z,
}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
def test_UpdateExpr(self):
subscript = Subscript(self.y)
expr = UpdateExpr(self.z, subscript, self.x)
label_subscript_expr = Subscript(self.y_label)
subscript_label = self.context.Label(
subscript, IntegerIntervalArray([self.state[self.y]]), None)
label_expr = UpdateExpr(self.z_label, subscript_label, self.x_label)
new_bound = IntegerIntervalArray([1, 2, 3, IntegerInterval([1, 2])])
label = self.context.Label(expr, new_bound, None)
env = {
label: label_expr,
subscript_label: label_subscript_expr,
self.x_label: self.x,
self.y_label: self.y,
self.z_label: self.z,
}
test_value = LabelSemantics(label, env)
self.compare(expr, test_value)
def test_UpdateExpr(self):
test_expr = UpdateExpr(self.a, (self.x, self.y), IntegerInterval(2))
test_value = IntegerIntervalArray(
[[IntegerInterval([1, 2]), 2], [IntegerInterval([2, 3]), 4]])
value = arith_eval(test_expr, self.array_state)
self.assertEqual(test_value, value)
def test_numeral(self):
expr = IntegerInterval(1)
label = self.context.Label(expr, expr, None)
test_value = LabelSemantics(label, {label: expr})
self.compare(expr, test_value)
def _list_elements_to_interval(self, values):
return [[IntegerInterval(e) for e in l] for l in values]
def test_matrix_getter(self):
self.assertEqual(self.matrix[1, 2], IntegerInterval([6, 9]))
self.assertEqual(self.matrix[[0, 1], 1], IntegerInterval([2, 9]))
def test_AccessExpr(self):
test_expr = AccessExpr(self.a, (self.x, self.y))
test_value = IntegerInterval([1, 3])
value = arith_eval(test_expr, self.array_state)
self.assertEqual(test_value, value)