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)