def test_tile_generator_hint1(self):
capacity_list = [512, 131072]
access_cost_list = [1, 64]
static_cost_list = [0.2, 4096 * 0.2]
para_count_list = [12, 1]
# {loop: [level, order, blocking, partitioning]}
schedule_hint = {
cm.le.FX: [[0, 3, 1], None],
cm.le.IC: [[1, 8, 1], None],
cm.le.FY: [[2, 1, 3], None],
cm.le.OY: [[3, 1, 4], None],
cm.le.OX: [[4, 1, 1], None],
cm.le.OC: [[5, 1, 1], None],
cm.le.ON: [[6, 1, 1], None]
}
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0],
[2])
layer = cm.Layer(64, 32, 8, 8, 3, 3, 1)
tile_generator = cm.mapping_point_generator.blocking_partitioning_generator_function_with_hint(
resource, layer, schedule_hint)
expect_result = [[(3, 1), (1, 1), (1, 8), (1, 2), (1, 32), (8, 8),
(1, 1)],
[(1, 1), (3, 1), (1, 1), (4, 1), (1, 1), (1, 1),
(1, 1)]]
self.assertEqual(next(tile_generator), expect_result)
def test_invalide_partition(self):
capacity_list = [512, 16384, 262144, 2097152]
access_cost_list = [1, 6, 23, 64]
static_cost_list = [0.2, 32 * 0.2, 512 * 0.2, 4096 * 0.2]
para_count_list = [4, 16]
para_shared_level_list = [2, 4]
loop_order_list = [(0, 2, 1, 1), (1, 3, 2, 2), (2, 0, 3, 3),
(3, 1, 4, 4), (4, 4, 0, 5), (5, 5, 5, 0),
(6, 6, 6, 6)]
loop_blockings_list = [(3, 1, 1, 1), (3, 1, 1, 1), (1, 128, 1, 1),
(1, 256, 1, 1), (1, 1, 128, 1), (1, 1, 1, 16),
(1, 1, 1, 1)]
loop_partitionings_list = [(1, 1, 1, 1), (1, 1, 1, 1), (
1,
4,
1,
1,
), (1, 2, 1, 1), (1, 1, 1, 1), (1, 1, 1, 16), (1, 1, 1, 1)]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list,
para_shared_level_list)
layer = cm.Layer(256, 128, 512, 512, 3, 3, 1)
cost = cm.cost_model.get_cost(resource, point, layer, True)
real_cost = float("inf")
self.assertEqual(cost, real_cost)
def test_simple(self):
capacity_list = [512, 16384, 262144, 2097152]
access_cost_list = [1, 6, 23, 64]
static_cost_list = [0.2, 32 * 0.2, 512 * 0.2, 4096 * 0.2]
para_count_list = [4, 16]
para_shared_level_list = [2, 4]
loop_order_list = [(0, 2, 1, 1), (1, 3, 2, 2), (2, 0, 3, 3),
(3, 1, 4, 4), (4, 4, 0, 5), (5, 5, 5, 0),
(6, 6, 6, 6)]
loop_blockings_list = [(3, 1, 1, 1), (3, 1, 1, 1), (1, 4, 1, 1),
(1, 4, 1, 1), (1, 1, 32, 1), (1, 1, 1, 4),
(1, 1, 1, 1)]
loop_partitionings_list = [(1, 1, 1, 1), (1, 1, 1, 1), (
1,
2,
1,
1,
), (1, 2, 1, 1), (1, 1, 1, 1), (1, 1, 1, 16), (1, 1, 1, 1)]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list,
para_shared_level_list)
layer = cm.Layer(64, 32, 8, 8, 3, 3, 1)
cost = cm.cost_model.get_cost(resource, point, layer, True)
real_cost = (6400 * 32 + 2048 * 64 + 18432 * 64) + (
6400 * 32 + 2048 * 64 + 18432 * 1) * 6 + (
6400 + 2048 * 64 + 18432) * 23 + (6400 + 2048 + 18432) * 64
self.assertEqual(cost, real_cost)
def test_alex_conv1(self):
reg0_size = 4
reg1_size = 32
reg0_cost = 0.1/8
reg1_cost = 0.1
capacity_list = [64/2, 512/2, 131072/2, 2097152*256] #32B, 32KB
access_cost_list = [0.1, 1, 6, 200]
static_cost_list = [0, 0, 0, 0]
para_count_list = [1, 156, 1, 1]
# {loop: [[order, blocking, partitioning],[],...]}
schedule_hint = {cm.le.FY: [None, [2, 1, 11], None, None], cm.le.OY: [None, [3, 1, 3], None, None],
cm.le.IC: [None, [4, None, 2], None, None]}
layer = cm.Layer(3, 96, 55, 55, 11, 11, 16, 4, 4)
energy_list = np.zeros((4,4))
for x in xrange(0, 4):
capacity_list[1] = reg1_size * (2**x)
access_cost_list[1] = reg1_cost * (2**x)
for y in xrange(0, 4):
capacity_list[0] = reg0_size * (2**y)
access_cost_list[0] = reg0_cost * (2**y)
resource = cm.Resource(capacity_list, access_cost_list, static_cost_list, para_count_list, 0, [0, 1, 0, 0], [2])
opt_result = cm.optimizer.opt_optimizer(resource, layer, schedule_hint, True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 2)
level3 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 3)
level00 = cm.cost_model.get_array_and_curr_level_cost(resource, opt_result[1], layer, 2) - level2
print level0, level1, level00, level2, level3
cm.utils.print_loop_nest(opt_result[1])
energy_list[x][y] = opt_result[0]
print list(energy_list)
def test_parallel_blocking(self):
'''test non-exact divide case'''
capacity_list = [512, 131072, 2097152]
access_cost_list = [1, 6, 64]
static_cost_list = [0.2, 32 * 0.2, 4096 * 0.2]
para_count_list = [12, 1, 1]
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0, 0],
[2])
layer = cm.Layer(32, 32, 16, 16, 3, 3, 4)
loop_blocking = [(3, 1, 1), (3, 1, 1), (1, 16, 1), (4, 4, 1),
(8, 2, 2), (2, 4, 8), (4, 1, 1)]
parallel_generator = cm.mapping_point_generator.parallel_blocking_generator_function(
zip(*loop_blocking), resource, layer, under_utilized=True)
expected_result = ([1, 1, 1, 1, 1, 2, 4], [1, 1, 1, 1, 1, 1,
1], [1, 1, 1, 1, 1, 1, 1])
self.assertEqual(next(parallel_generator), expected_result)
expected_result = ([1, 1, 1, 1, 2, 1, 4], [1, 1, 1, 1, 1, 1,
1], [1, 1, 1, 1, 1, 1, 1])
self.assertEqual(next(parallel_generator), expected_result)
expected_result = ([1, 1, 1, 1, 2, 2, 3], [1, 1, 1, 1, 1, 1,
1], [1, 1, 1, 1, 1, 1, 1])
self.assertEqual(next(parallel_generator), expected_result)
def test_simple(self):
capacity_list = [512, 131072]
access_cost_list = [1, 64]
static_cost_list = [0.2, 4096 * 0.2]
para_count_list = [16, 1]
loop_order_list = [(0, 6), (2, 6), (6, 0), (3, 1), (6, 3), (1, 2),
(6, 4)]
loop_blockings_list = [(3, 1), (1, 1), (1, 8), (1, 2), (1, 32), (8, 8),
(1, 1)]
loop_partitionings_list = [(1, 1), (3, 1), (1, 1), (4, 1), (1, 1),
(1, 1), (1, 1)]
para_dim_list = [[[1], [3]], None]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list, para_dim_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0],
[2])
layer = cm.Layer(64, 32, 8, 8, 3, 3, 1)
cm.utils.print_loop_nest(point)
cost = cm.cost_model.get_cost(resource, point, layer, True)
real_cost = (6400 * 288 + 2048 * 1151 +
18432 * 64) + (6400 * 96 + 2048 * 24 + 18432 * 4) * 2 + (
6400 * 32 + 2048 * 15 + 18432 * 1) * 64
self.assertEqual(cost, real_cost)
def test_3d_in_2d(self):
capacity_list = [512, 131072]
access_cost_list = [1, 64]
static_cost_list = [0.2, 4096 * 0.2]
para_count_list = [16, 1]
loop_order_list = [(0, 6), (2, 6), (6, 0), (3, 1), (6, 3), (1, 2),
(6, 4)]
loop_blockings_list = [(3, 1), (1, 1), (1, 8), (1, 2), (1, 32), (1, 8),
(1, 1)]
loop_partitionings_list = [(1, 1), (3, 1), (1, 1), (4, 1), (1, 1),
(16, 1), (1, 1)]
para_dim_list = [[[1, 3], [5]], None]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list, para_dim_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0],
[2])
layer = cm.Layer(128, 32, 8, 8, 3, 3, 1)
cm.utils.print_loop_nest(point)
cost = cm.cost_model.get_cost(resource, point, layer, True)
real_cost = (12800 * 288 + 2048 * 2303 + 36864 * 64) + (
12800 * 96 + 2048 * 384 + 36864 * 1) * 2 + (36864 * 4) * 6 + (
12800 * 32 + 2048 * 15 + 36864 * 1) * 64
self.assertEqual(cost, real_cost)
cost_levels = cm.cost_model.get_level_cost(resource, point, layer, 0, True) + \
cm.cost_model.get_array_and_curr_level_cost(resource, point, layer, 1, True)
self.assertEqual(cost, cost_levels)
def test_level_cost(self):
capacity_list = [512, 131072]
access_cost_list = [1, 64]
static_cost_list = [0.2, 4096 * 0.2]
para_count_list = [12, 1]
para_dim_list = [[[1], [3]], None]
loop_order_list = [(0, 6), (2, 6), (6, 0), (3, 1), (6, 3), (1, 2),
(6, 4)]
loop_blockings_list = [(3, 1), (1, 1), (1, 8), (1, 2), (1, 32), (8, 8),
(1, 1)]
loop_partitionings_list = [(1, 1), (3, 1), (1, 1), (4, 1), (1, 1),
(1, 1), (1, 1)]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list, para_dim_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0],
[2])
layer = cm.Layer(64, 32, 8, 8, 3, 3, 1)
cm.utils.print_loop_nest(point)
cost_total = cm.cost_model.get_cost(resource, point, layer, True)
cost_levels = cm.cost_model.get_level_cost(resource, point, layer, 0, True) + \
cm.cost_model.get_array_and_curr_level_cost(resource, point, layer, 1, True)
self.assertEqual(cost_total, cost_levels)
def test_4d_in_2d(self):
capacity_list = [512, 131072]
access_cost_list = [1, 64]
static_cost_list = [0.2, 4096 * 0.2]
para_count_list = [16, 1]
loop_order_list = [(0, 6), (2, 6), (6, 0), (3, 1), (6, 3), (1, 2),
(4, 4)]
loop_blockings_list = [(3, 1), (1, 1), (1, 8), (1, 2), (1, 32), (2, 8),
(1, 1)]
loop_partitionings_list = [(1, 1), (3, 1), (1, 1), (4, 1), (1, 1),
(4, 1), (4, 1)]
para_dim_list = [[[1, 3], [5, 6]], None]
point = cm.MappingPoint(loop_order_list, loop_blockings_list,
loop_partitionings_list, para_dim_list)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0],
[2])
layer = cm.Layer(64, 32, 8, 8, 3, 3, 4)
cm.utils.print_loop_nest(point)
cost = cm.cost_model.get_cost(resource, point, layer, True)
real_cost = (25600 * 288 + 8192 * 1151 + 18432 * 256) + (
25600 * 96 + 8192 * 96 + 18432 * 1) * 2 + (18432 * 4) * 6 + (
18432 * 4) * 8 + (25600 * 32 + 8192 * 15 + 18432 * 1) * 64
#self.assertEqual(cost, real_cost)
cost_levels = cm.cost_model.get_level_cost(resource, point, layer, 0, True) + \
cm.cost_model.get_array_and_curr_level_cost(resource, point, layer, 1, True)
self.assertEqual(cost, cost_levels)
def test_parallel_blocking_partial_hint3(self):
capacity_list = [512, 131072, 2097152]
access_cost_list = [1, 6, 64]
static_cost_list = [0.2, 32 * 0.2, 4096 * 0.2]
para_count_list = [1, 64, 1]
# {loop: [level, order, blocking, partitioning]}
schedule_hint = {
cm.le.OX: [None, [1, None, 4], None],
cm.le.OC: [None, [2, None, 4], None]
}
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [0, 1, 0],
[2], [cm.le.OC, cm.le.IC, cm.le.ON])
layer = cm.Layer(32, 32, 16, 16, 3, 3, 4, 4, 4)
loop_blocking = [(3, 1, 1), (3, 1, 1), (1, 16, 1), (4, 4, 1),
(2, 8, 2), (2, 4, 8), (1, 4, 1)]
parallel_generator = cm.mapping_point_generator.parallel_blocking_generator_function(
zip(*loop_blocking), resource, layer, schedule_hint)
self.assertEqual(next(parallel_generator),
([1, 1, 1, 1, 1, 1, 1], [1, 1, 4, 1, 4, 1, 2
], [1, 1, 1, 1, 1, 1, 1]))
self.assertEqual(next(parallel_generator),
([1, 1, 1, 1, 1, 1, 1], [1, 1, 4, 1, 4, 2, 1
], [1, 1, 1, 1, 1, 1, 1]))
self.assertEqual(next(parallel_generator),
([1, 1, 1, 1, 1, 1, 1], [1, 1, 4, 1, 8, 1, 1
], [1, 1, 1, 1, 1, 1, 1]))
def test_alex_conv1(self):
capacity_list = [64 / 2, 131072 / 2, 2097152 * 256]
access_cost_list = [0.1, 6, 200]
static_cost_list = [0, 0, 0]
para_count_list = [192, 1, 1]
# {loop: [[order, blocking, partitioning],[],...]}
#schedule_hint = {cm.le.FX: [[0, 5, 1], None, None], cm.le.IC: [[3, 1, 12], None, None],
# cm.le.FY: [[1, 5, 1], None, None], cm.le.OY: [[5, 1, 1], None, None],
# cm.le.OX: [[4, 1, 1], None, None], cm.le.OC: [[4, 1, 16], None, None],
# cm.le.ON: [[6, 1, 1], None, None]}
schedule_hint = {
cm.le.IC: [[3, 1, 3], None, None],
cm.le.OC: [[5, None, 16], None, None],
cm.le.ON: [[4, None, 4], None, None]
}
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0, 0],
[2])
layer = cm.Layer(3, 96, 55, 55, 11, 11, 16, 4, 4)
opt_result = cm.optimizer.opt_optimizer(resource, layer, schedule_hint,
True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
2)
level00 = cm.cost_model.get_array_and_curr_level_cost(
resource, opt_result[1], layer, 1) - level1
print level0, level00, level1, level2
cm.utils.print_loop_nest(opt_result[1])
def test_dataflow_explore(self):
capacity_list = [32, 131072, 2097152]
access_cost_list = [0.1, 6, 64]
static_cost_list = [0.2, 32 * 0.2, 4096 * 0.2]
para_count_list = [12, 1, 1]
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0, 0],
[2])
layer = cm.Layer(32, 32, 16, 16, 3, 3, 4)
dataflow_tb = cm.mapping_point_generator.dataflow_exploration(
resource, layer, True)
print "dataflows:", dataflow_tb
def test_tile_generator_hint5(self):
capacity_list = [32, 512, 2097152]
access_cost_list = [1, 6, 64]
static_cost_list = [0.2, 32 * 0.2, 4096 * 0.2]
para_count_list = [1, 16, 1]
# {loop: [level, order, blocking, partitioning]}
schedule_hint = {
cm.le.FX: [None, [0, 3, 1], None],
cm.le.IC: [None, [1, None, 4], None],
cm.le.OC: [None, [2, None, 4], None]
}
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [0, 1, 0],
[2])
layer = cm.Layer(64, 32, 8, 8, 3, 3, 1)
def test_alex_conv1(self):
reg_size = 16
buffer_size = 16384
reg_cost = 0.05
buffer_cost = 3.84
capacity_list = [512 / 2, 131072 / 2, 2097152 * 256] #32B, 32KB
access_cost_list = [1, 6, 200]
static_cost_list = [0, 0, 0]
para_count_list = [192, 1, 1]
# {loop: [[order, blocking, partitioning],[],...]}
schedule_hint = {
cm.le.IC: [[3, 1, 3], None, None],
cm.le.OC: [[5, None, 16], None, None],
cm.le.ON: [[4, None, 4], None, None]
}
layer = cm.Layer(3, 96, 55, 55, 11, 11, 16, 4, 4)
energy_list = np.zeros((5, 5))
for x in xrange(0, 5):
capacity_list[1] = buffer_size * (2**x)
access_cost_list[1] = buffer_cost * (1.25**x)
for y in xrange(0, 5):
capacity_list[0] = reg_size * (2**y)
access_cost_list[0] = reg_cost * (2**y)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0,
[1, 0, 0], [2])
opt_result = cm.optimizer.opt_optimizer(
resource, layer, schedule_hint, True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 2)
level00 = cm.cost_model.get_array_and_curr_level_cost(
resource, opt_result[1], layer, 1) - level1
print level0, level00, level1, level2
cm.utils.print_loop_nest(opt_result[1])
energy_list[x][y] = opt_result[0]
print list(energy_list)
def test_vgg_conv12(self):
capacity_list = [512/2, 131072/2, 2097152*1024]
access_cost_list = [1, 6, 200]
static_cost_list = [0, 0, 0]
para_count_list = [256, 1, 1]
# {loop: [[order, blocking, partitioning],[],...]}
schedule_hint = {cm.le.IC: [[3, None, 16], None, None],
cm.le.OC: [[4, None, 16], None, None]}
resource = cm.Resource(capacity_list, access_cost_list, static_cost_list, para_count_list, 0, [1, 0, 0], [2])
layer = cm.Layer(512, 512, 14, 14, 3, 3, 1)
opt_result = cm.optimizer.opt_optimizer(resource, layer, schedule_hint, True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1], layer, 2)
level00 = cm.cost_model.get_array_and_curr_level_cost(resource, opt_result[1], layer, 1) - level1
print level0, level00, level1, level2
cm.utils.print_loop_nest(opt_result[1])
def test_alex_conv1(self):
para_count = 48
para_cost = 2 / 1.4 / 1.4
capacity_list = [64 / 2, 131072 / 2, 2097152 * 256] #32B, 32KB
access_cost_list = [0.1, 6, 200]
static_cost_list = [0, 0, 0]
para_count_list = [192, 1, 1]
para_cost_list = [2]
# {loop: [[order, blocking, partitioning],[],...]}
schedule_hint = {
cm.le.IC: [[3, 1, 3], None, None],
cm.le.OC: [[5, None, 4], None, None],
cm.le.ON: [[4, None, 4], None, None]
}
layer = cm.Layer(3, 96, 55, 55, 11, 11, 16, 4, 4)
energy_list = [0.0] * 8
for x in xrange(0, 8):
para_count_list[0] = para_count * (2**x)
para_cost_list[0] = para_cost * (1.4**x)
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0,
[1, 0, 0], para_cost_list,
[cm.le.OC, cm.le.ON])
opt_result = cm.optimizer.opt_optimizer(resource, layer,
schedule_hint, True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1],
layer, 2)
level00 = cm.cost_model.get_array_and_curr_level_cost(
resource, opt_result[1], layer, 1) - level1
print level0, level00, level1, level2
cm.utils.print_loop_nest(opt_result[1])
energy_list[x] = opt_result[0]
print energy_list
def test_alex_conv3(self):
capacity_list = [512 / 2, 131072 / 2, 2097152 * 256]
access_cost_list = [1, 6, 200]
static_cost_list = [0, 0, 0]
para_count_list = [256, 1, 1]
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list, 0, [1, 0, 0],
[2])
layer = cm.Layer(256, 384, 13, 13, 3, 3, 1)
opt_result = cm.optimizer.opt_optimizer(resource, layer, None, True)
level0 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
0)
level1 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
1)
level2 = cm.cost_model.get_level_cost(resource, opt_result[1], layer,
2)
level00 = cm.cost_model.get_array_and_curr_level_cost(
resource, opt_result[1], layer, 1) - level1
print level0, level00, level1, level2
cm.utils.print_loop_nest(opt_result[1])
def test_tile_generator(self):
capacity_list = [512, 4096, 262144]
access_cost_list = [1, 6, 23]
static_cost_list = [0.2, 32 * 0.2, 512 * 0.2]
para_count_list = [1, 4, 1]
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list)
layer = cm.Layer(1, 1, 6, 6, 1, 1, 1)
tile_generator = cm.mapping_point_generator.blocking_generator_function(
resource, layer)
expect_result = [[1, 1, 1], [1, 1, 1], [1, 1, 6], [1, 1, 6], [1, 1, 1],
[1, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[1, 1, 1], [1, 1, 1], [1, 1, 6], [1, 2, 3], [1, 1, 1],
[1, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[1, 1, 1], [1, 1, 1], [1, 1, 6], [1, 3, 2], [1, 1, 1],
[1, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[1, 1, 1], [1, 1, 1], [1, 1, 6], [1, 6, 1], [1, 1, 1],
[1, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
def test_tile_generator_hint(self):
capacity_list = [512, 8192, 2097152]
access_cost_list = [1, 6, 64]
static_cost_list = [0.2, 32 * 0.2, 4096 * 0.2]
para_count_list = [8, 1, 1]
schedule_hint = {
cm.le.FX: [[0, 3, 1], None, None],
cm.le.IC: [[1, 4, 2], None, None],
cm.le.FY: [[2, 3, 1], None, None],
cm.le.OY: [[3, 1, 4], None, None],
cm.le.OX: [[4, 1, 1], None, None],
cm.le.OC: [[5, 1, 1], None, None],
cm.le.ON: [[6, 1, 1], None, None]
}
resource = cm.Resource(capacity_list, access_cost_list,
static_cost_list, para_count_list)
layer = cm.Layer(8, 4, 8, 8, 3, 3, 1)
tile_generator = cm.mapping_point_generator.blocking_generator_function(
resource, layer, schedule_hint)
expect_result = [[3, 1, 1], [3, 1, 1], [1, 8, 1], [4, 1, 2], [1, 1, 4],
[8, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[3, 1, 1], [3, 1, 1], [1, 8, 1], [4, 1, 2], [1, 2, 2],
[8, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[3, 1, 1], [3, 1, 1], [1, 8, 1], [4, 1, 2], [1, 4, 1],
[8, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[3, 1, 1], [3, 1, 1], [1, 8, 1], [4, 2, 1], [1, 1, 4],
[8, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
expect_result = [[3, 1, 1], [3, 1, 1], [1, 8, 1], [4, 2, 1], [1, 2, 2],
[8, 1, 1], [1, 1, 1]]
self.assertEqual(next(tile_generator), expect_result)
