def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(8, 16, 28, 3) self.layers['POOL'] = PoolingLayer(16, 28, 2) self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1) self.batch_size = 4 self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=50, unit_static=50) self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 4), type=NodeRegion.PROC), data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DATA),), dim_array=PhyDim2(16, 16), size_gbuf=65536, size_regf=64) self.options = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, ntops=10) self.ifmap_layouts = {} part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP), pdims=((1, 2), (2, 1), (1, 2), (2, 1))) for wlkey in self.layers: self.ifmap_layouts[wlkey] = partition.get_ofmap_layout( self.layers[wlkey].input_layer(), self.batch_size, part, self.resource.src_data_region())
def test_gen_segment_not_opt(self): ''' gen_segment() not with_opt. ''' options_with_opt = Option(partition_interlayer=True, hw_gbuf_save_writeback=True, layer_pipeline_opt=True) options_not_opt = Option(partition_interlayer=True, hw_gbuf_save_writeback=True, layer_pipeline_opt=False) # Linear ones for net_name in ['net1', 'net2', 'zfnet']: net = self.net[net_name] ilp = self._make_ilp(net) segs_with_opt = set(seg.seg for seg in ilp.gen_segment(options_with_opt)) segs_not_opt = set(seg.seg for seg in ilp.gen_segment(options_not_opt)) self.assertSetEqual(segs_with_opt, segs_not_opt) # Non-linear ones for net_name in ['net3', 'net4', 'net5', 'net6', 'net7', 'googlenet']: net = self.net[net_name] ilp = self._make_ilp(net) segs_with_opt = set(seg.seg for seg in ilp.gen_segment(options_with_opt)) segs_not_opt = set(seg.seg for seg in ilp.gen_segment(options_not_opt)) self.assertTrue(segs_with_opt.issuperset(segs_not_opt))
def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(8, 16, 28, 3) self.layers['POOL'] = PoolingLayer(16, 28, 2) self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1) self.batch_size = 4 self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=50, idl_unit=50) self.none_cstr = SchedulingConstraint() self.cstr = SchedulingConstraint(topofm=1, topbat=self.batch_size) self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 4), type=NodeRegion.PROC), dram_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DRAM), src_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DRAM), dst_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DRAM), dim_array=PhyDim2(16, 16), size_gbuf=65536, size_regf=64, array_bus_width=float('inf'), dram_bandwidth=float('inf'), no_time_mux=False) self.options = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, ntops=10) self.ifmap_layouts = {} part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP), pdims=((1, 2), (2, 1), (1, 2), (2, 1))) for wlkey in self.layers: input_layer = self.layers[wlkey].input_layer() self.ifmap_layouts[wlkey] = DataLayout( frngs=(FmapRange((0, 0, 0, 0), FmapPosition(b=self.batch_size, n=input_layer.nofm, h=input_layer.hofm, w=input_layer.wofm)), ), regions=(self.resource.src_data_region, ), parts=(part.projection(self.resource.src_data_region, appl2frng=True), )) self.sched_seq = (2, 0, 1)
def test_invalid_time_ovhd(self): ''' Invalid layer_pipeline_time_ovhd. ''' with self.assertRaisesRegexp(KeyError, 'Option: .*layer_pipeline_time_ovhd.*'): _ = Option(layer_pipeline_time_ovhd=None) with self.assertRaisesRegexp(ValueError, 'Option: .*layer_pipeline_time_ovhd.*'): _ = Option(layer_pipeline_time_ovhd=-1)
def test_invalid_max_degree(self): ''' Invalid layer_pipeline_max_degree. ''' with self.assertRaisesRegexp(KeyError, 'Option: .*layer_pipeline_max_degree.*'): _ = Option(layer_pipeline_max_degree=None) with self.assertRaisesRegexp(ValueError, 'Option: .*layer_pipeline_max_degree.*'): _ = Option(layer_pipeline_max_degree=-1)
def test_opt_goal(self): ''' Optimization goal. ''' network = self.alex_net batch_size = 8 resource = self.resource._replace( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(8, 8), type=NodeRegion.PROC) ) nnd = NNDataflow(network, batch_size, resource, self.cost, self.map_strategy) options_e = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True, partition_hybrid=True, partition_batch=True, opt_goal='e', ntops=16) tops_e, _ = nnd.schedule_search(options_e) self.assertTrue(tops_e) options_d = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True, partition_hybrid=True, partition_batch=True, opt_goal='d', ntops=16) tops_d, _ = nnd.schedule_search(options_d) self.assertTrue(tops_d) options_ed = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True, partition_hybrid=True, partition_batch=True, opt_goal='ed', ntops=16) tops_ed, _ = nnd.schedule_search(options_ed) self.assertTrue(tops_ed) self.assertLess(tops_e[0].total_cost, tops_d[0].total_cost) self.assertLess(tops_e[0].total_cost, tops_ed[0].total_cost) self.assertLess(tops_d[0].total_time, tops_e[0].total_time) self.assertLess(tops_d[0].total_time, tops_ed[0].total_time) # Sum of the smallest ED may not be the smallest; allow for error. self.assertLess(tops_ed[0].total_cost * tops_ed[0].total_time, tops_e[0].total_cost * tops_e[0].total_time * 1.05) self.assertLess(tops_ed[0].total_cost * tops_ed[0].total_time, tops_d[0].total_cost * tops_d[0].total_time * 1.05)
def test_gen_segment(self): ''' gen_segment(). ''' for net_name in self.net: net = self.net[net_name] ilp = self._make_ilp(net) # No pipelining. options = Option() segs_n_lst = list(ilp.gen_segment(options)) segs_n = set(segs_n_lst) self.assertEqual(len(segs_n_lst), len(segs_n)) for seg in segs_n: self.assertEqual(len(seg), 1) self.assertEqual(len(seg[0]), 1) self.assertIn(seg[0][0], net) # Spatial pipelining. options = Option(partition_interlayer=True) segs_sp_lst = list(ilp.gen_segment(options)) segs_sp = set(segs_sp_lst) self.assertEqual(len(segs_sp_lst), len(segs_sp)) for seg in segs_sp: for ltpl in seg: self.assertLessEqual(sum(1 for l in ltpl if isinstance(l, ConvLayer)), 1) self.assertTrue(segs_sp.issuperset(segs_n)) # Temporal pipelining. options = Option(hw_gbuf_save_writeback=True) segs_tp_lst = list(ilp.gen_segment(options)) segs_tp = set(segs_tp_lst) self.assertEqual(len(segs_tp_lst), len(segs_tp)) for seg in segs_tp: self.assertEqual(len(seg), 1) self.assertTrue(segs_tp.issuperset(segs_n)) # Spatial and temporal pipelining. options = Option(partition_interlayer=True, hw_gbuf_save_writeback=True) segs_stp_lst = list(ilp.gen_segment(options)) segs_stp = set(segs_stp_lst) self.assertEqual(len(segs_stp_lst), len(segs_stp)) self.assertSetEqual(segs_stp, segs_tp | segs_sp) # Only single-layer and single-vertex segments have the same # spatial and temporal pipelining. segs_intersect = segs_tp & segs_sp segs_single = segs_n segs_single |= set(PipelineSegment((v,), ilp.network, ilp.batch_size, ilp.resource) for v in ilp.dag_vertex_list) self.assertTrue(segs_intersect.issubset(segs_single))
def test_pernode_sched_cache_key(self): ''' Per-node scheduling cache key must be hash-able. ''' layer = self.layers['BASE'] ifmap_layout = self.ifmap_layouts['BASE'] schd = Scheduling(layer, self.batch_size, self.cost, MapStrategyEyeriss) condition = SchedulingCondition(resource=self.resource, ifmap_layout=ifmap_layout) _ = schd.schedule_search(condition, self.options) h, m = schd.cache_stats() self.assertEqual(h, 0) # Make another instance. rsrc = Resource(**self.resource._asdict()) opts = Option(**self.options._asdict()) self.assertNotEqual(id(rsrc), id(self.resource)) self.assertNotEqual(id(opts), id(self.options)) part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP), pdims=((2, 2), (2, 2), (1, 1), (1, 1))) _ = schd.schedule_search_per_node(part, rsrc, opts) h2, m2 = schd.cache_stats() self.assertEqual(h2, h + 1) self.assertEqual(m2, m)
def setUp(self): self.alex_net = import_network('alex_net') self.vgg_net = import_network('vgg_net') self.map_strategy = MapStrategyEyeriss self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC), data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DATA), ), dim_array=PhyDim2(16, 16), size_gbuf=128 * 1024 // 2, # 128 kB size_regf=512 // 2, # 512 B ) self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=0, unit_static=0) self.options = Option()
def test_valid_args(self): ''' Valid arguments. ''' options = Option((False, True, False), True) self.assertEqual(options.sw_gbuf_bypass, (False, True, False), 'sw_gbuf_bypass') self.assertEqual(options.sw_solve_loopblocking, True, 'sw_solve_loopblocking')
def test_verbose(self): ''' Verbose mode. ''' network = self.alex_net batch_size = 16 options = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True, verbose=True) nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = stdout = StringIO() sys.stderr = stderr = StringIO() tops, _ = nnd.schedule_search(options) sys.stdout = old_stdout sys.stderr = old_stderr stdout_value = stdout.getvalue() stderr_value = stderr.getvalue() stdout.close() stderr.close() self.assertTrue(tops) self.assertFalse(stdout_value) for layer in network: self.assertIn(layer, stderr_value)
def test_valid_kwargs(self): ''' Valid keyword arguments. ''' options = Option(sw_gbuf_bypass=(False, False, False), sw_solve_loopblocking=False, hw_access_forwarding=False, hw_gbuf_sharing=False, partition_hybrid=True, partition_batch=False, partition_ifmaps=False, partition_interlayer=False, opt_goal='ed', ntops=10, nprocesses=16, verbose=False ) self.assertEqual(options.sw_gbuf_bypass, (False, False, False), 'sw_gbuf_bypass') self.assertEqual(options.sw_solve_loopblocking, False, 'sw_solve_loopblocking') self.assertEqual(options.hw_access_forwarding, False, 'hw_access_forwarding') self.assertEqual(options.hw_gbuf_sharing, False, 'hw_gbuf_sharing') self.assertEqual(options.partition_hybrid, True, 'partition_hybrid') self.assertEqual(options.partition_batch, False, 'partition_batch') self.assertEqual(options.partition_ifmaps, False, 'partition_ifmaps') self.assertEqual(options.partition_interlayer, False, 'partition_interlayer') self.assertEqual(options.opt_goal, 'ed', 'opt_goal') self.assertEqual(options.ntops, 10, 'ntops') self.assertEqual(options.nprocesses, 16, 'nprocesses') self.assertEqual(options.verbose, False, 'verbose')
def test_gen_segment_lstm(self): ''' gen_segment() with LSTM cell. ''' net = self.net['lstm_phoneme'] ilp = self._make_ilp(net) options = Option(partition_interlayer=True) # Find a cell. cname = None for l in net: if l[-6:] == '_igate': cname = l[:-6] self.assertIsNotNone(cname) # One LSTM cell fits. segment = PipelineSegment( ((cname + '_cand',), (cname + '_igate', cname + '_cout_i'), (cname + '_fgate', cname + '_cout_f', cname + '_cout'), (cname + '_ogate', cname + '_hout')), ilp.network, ilp.batch_size, ilp.resource) self.assertTrue(segment.valid) segs = set(seg.seg for seg in ilp.gen_segment(options)) self.assertIn(segment.seg, segs)
def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(64, 64, 28, 3) self.layers['FC'] = FCLayer(4096, 1000, 6) self.layers['POOL'] = PoolingLayer(32, 7, 3, strd=2) self.layers['LR'] = LocalRegionLayer(32, 7, nreg=5, sreg=1) # With irregular nifm/nofm. self.layers['IRR'] = ConvLayer(255, 383, 13, 3) # With small numbers of fmaps. self.layers['SM'] = ConvLayer(5, 3, 13, 3) # Super small networks. No partitioning schemes. self.layers['SSM1'] = ConvLayer(1, 1, 2, 3) self.layers['SSM2'] = FCLayer(2, 2) self.layers['SSM3'] = PoolingLayer(1, 2, 2) self.batch_size = 8 self.dim_nodes = {} self.dim_nodes['BASE'] = PhyDim2(4, 4) self.dim_nodes['LG'] = PhyDim2(10, 10) self.dim_nodes['PRIME'] = PhyDim2(3, 3) self.options = {} # Irrelevant options. optdict = {'ntops': 10000} self.options['BASE'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, **optdict) self.options['NOBATP'] = Option(partition_hybrid=True, partition_batch=False, partition_ifmaps=True, **optdict) self.options['NOINPP'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=False, **optdict) self.options['NOHYB'] = Option(partition_hybrid=False, partition_batch=True, partition_ifmaps=False, **optdict)
def test_default_args(self): ''' Default arguments. ''' options = Option() self.assertTupleEqual(options.sw_gbuf_bypass, (False, False, False)) self.assertEqual(options.sw_solve_loopblocking, False) self.assertEqual(options.partition_hybrid, False) self.assertEqual(options.partition_batch, False) self.assertEqual(options.partition_ifmaps, False) self.assertEqual(options.ntops, 1) self.assertEqual(options.nprocesses, 1) self.assertEqual(options.verbose, False)
def setUp(self): self.alex_net = import_network('alex_net') self.vgg_net = import_network('vgg_net') net = Network('simple') net.set_input_layer(InputLayer(4, 2)) net.add('1', ConvLayer(4, 4, 2, 1)) net.add('2', ConvLayer(4, 4, 2, 1)) # Two more layers to avoid single-segment case. net.add('a1', ConvLayer(4, 1, 1, 1, strd=2)) net.add('a2', ConvLayer(1, 1, 1, 1)) self.simple_net = net net = Network('complex') net.set_input_layer(InputLayer(8, 8)) net.add('1', ConvLayer(8, 8, 8, 1)) net.add('2a', ConvLayer(8, 8, 8, 1), prevs=('1', )) net.add('3a', ConvLayer(8, 8, 8, 1)) net.add('2b', ConvLayer(8, 8, 8, 1), prevs=('1', )) net.add('3b', ConvLayer(8, 8, 8, 1)) net.add('4', ConvLayer(16, 8, 8, 1), prevs=('3a', '3b')) self.complex_net = net self.map_strategy = MapStrategyEyeriss self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC), dram_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), src_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), dst_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), dim_array=PhyDim2(16, 16), size_gbuf=128 * 1024 // 2, # 128 kB size_regf=512 // 2, # 512 B array_bus_width=float('inf'), dram_bandwidth=float('inf'), no_time_mux=False, ) self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=0, idl_unit=0) self.options = Option()
def test_pipelining(self): ''' Pipelining. ''' network = self.alex_net batch_size = 1 options = Option(hw_gbuf_save_writeback=True, partition_interlayer=True) nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) tops, _ = nnd.schedule_search(options) self.assertTrue(tops)
def __init__(self, mlp_network): self.net = mlp_network #MLP_network(18,32,64,32,2) self.map_strategy = MapStrategyEyeriss self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC), data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DATA), ), dim_array=PhyDim2(16, 16), size_gbuf=128 * 1024 // 2, # 128 kB size_regf=512 // 2, # 512 B ) self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=0, unit_static=0) self.options = Option()
class TestMLP_network(): def __init__(self, mlp_network): self.net = mlp_network #MLP_network(18,32,64,32,2) self.map_strategy = MapStrategyEyeriss self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC), data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DATA), ), dim_array=PhyDim2(16, 16), size_gbuf=128 * 1024 // 2, # 128 kB size_regf=512 // 2, # 512 B ) self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=0, unit_static=0) self.options = Option() def test_eyeriss_isca16(self): network = self.net batch_size = 16 nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) tops, cache_stats = nnd.schedule_search(self.options) if not tops: sys.stderr.write("No valid dataflow found!") return None dfsch = tops[0] ## Write results. res_map = OrderedDict() res_map['net'] = "MLP_L" res_map['batch'] = batch_size res_map['resource'] = self.resource._asdict() res_map['cost'] = self.cost._asdict() res_map['options'] = self.options._asdict() res_map['cache_stats'] = cache_stats stats = stats_dict(dfsch, self.cost) for key, val in stats.items(): res_map[key] = val return res_map
def test_gen_segment_max_degree(self): ''' gen_segment() maximum degree. ''' net = self.net['vgg_net'] ilp = self._make_ilp(net) options = Option(partition_interlayer=True, hw_gbuf_save_writeback=True, layer_pipeline_max_degree=4) for segment in ilp.gen_segment(options): self.assertLessEqual(sum(1 if isinstance(net[l], ConvLayer) else 0 for ltpl in segment for l in ltpl), 4)
def _gen_all_partition(self, layerkey='PAR'): ''' Generate PartitionScheme. ''' options = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, ntops=2**30) for part in partition.gen_partition( self.layer[layerkey], self.batch_size, self.resource['PAR'].proc_region.dim, options): yield part
def setUp(self): super(TestLoopBlockingSolver, self).setUp() # Bypass solver for each reside data category. self.optkeys_bypsol = ['BYPSOL_{}'.format(dce) for dce in range(de.NUM)] for reside_dce in range(de.NUM): opt_dict = self.options['BYPSOL']._asdict() byp = [True] * de.NUM byp[reside_dce] = False opt_dict['sw_gbuf_bypass'] = tuple(byp) self.options[self.optkeys_bypsol[reside_dce]] = Option(**opt_dict)
def test_fast_forward_found(self): ''' Enter fast forward due to early found. ''' network = self.simple_net batch_size = 1 # No time overhead limit. options = Option(hw_gbuf_save_writeback=True, partition_interlayer=True, layer_pipeline_time_ovhd=float('inf')) nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) tops, _ = nnd.schedule_search(options) self.assertTrue(tops)
def test_gen_segment_vseg(self): ''' gen_segment() vertex segment. ''' for net_name in self.net: if not net_name.startswith('net'): continue net = self.net[net_name] ilp = self._make_ilp(net) options = Option(partition_interlayer=True) seg_set = set(ilp.gen_segment(options)) self.assertTrue(seg_set) seg_v_set = set(self._gen_all_segment(net)) self.assertTrue(seg_set.issubset(seg_v_set))
def test_gen_segment_one_nexts(self): ''' gen_segment() with missing one next vertex. ''' # pylint: disable=protected-access net = self.net['net4'] ilp = self._make_ilp(net) vseg_set = set(ilp._gen_vseg()) self.assertIn((7, 8), vseg_set) self.assertNotIn((4, 5, 6), vseg_set) options = Option(partition_interlayer=True) seg_set = set(ilp.gen_segment(options)) self.assertIn(self._make_segment((7, 8), ilp.network), seg_set) self.assertNotIn(self._make_segment((4, 5, 6), ilp.network), seg_set)
def test_gen_segment_multi_prevs(self): ''' gen_segment() with multiple previous vertices. ''' # pylint: disable=protected-access net = self.net['net4'] ilp = self._make_ilp(net) vseg_set = set(ilp._gen_vseg()) self.assertIn((9, 10), vseg_set) self.assertIn((13, 14), vseg_set) options = Option(partition_interlayer=True) seg_set = set(ilp.gen_segment(options)) # 10 only has neighbor source 9; 10p only has local source 10 and # memory source 8. Valid. self.assertIn(self._make_segment((9, 10), ilp.network), seg_set) # 14 has both neighbor source 13, and memory source 12, etc.. Invalid. self.assertNotIn(self._make_segment((13, 14), ilp.network), seg_set)
def test_ext_layer(self): ''' With external layers. ''' network = self.alex_net network.add_ext('e0', InputLayer(4, 1)) network.add('l1', FCLayer(1000, 4)) network.add('l2', FCLayer(8, 4), prevs=('e0', 'l1')) batch_size = 16 options = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True) nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) tops, _ = nnd.schedule_search(options) self.assertTrue(tops)
def test_gen_segment_resnet(self): ''' gen_segment() with ResNet. ''' net = self.net['resnet152'] ilp = self._make_ilp(net) options = Option(partition_interlayer=True) # One residual module fits. segment = PipelineSegment( (('conv3_2_a',), ('conv3_2_b',), ('conv3_2_c', 'conv3_2_res')), ilp.network, ilp.batch_size, ilp.resource) self.assertTupleEqual(net.prevs('conv3_2_res'), ('conv3_1_res', 'conv3_2_c')) self.assertTrue(segment.valid) segs = set(seg.seg for seg in ilp.gen_segment(options)) self.assertIn(segment.seg, segs)
def test_fmap_fwd(self): ''' Fmap forward with shared mem sources or both on/off-chip destinations. ''' network = self.complex_net batch_size = 16 # Multiple nodes for spatial pipelining. resource = self.resource._replace(proc_region=NodeRegion( origin=PhyDim2(0, 0), dim=PhyDim2(8, 8), type=NodeRegion.PROC), ) # No time overhead limit. options = Option(hw_gbuf_save_writeback=True, partition_interlayer=True, layer_pipeline_time_ovhd=float('inf')) nnd = NNDataflow(network, batch_size, resource, self.cost, self.map_strategy) tops, _ = nnd.schedule_search(options) self.assertTrue(tops)
def test_valid_kwargs(self): ''' Valid keyword arguments. ''' options = Option(sw_gbuf_bypass=(False, False, False), sw_solve_loopblocking=False, partition_hybrid=True, partition_batch=False, partition_ifmaps=False, ntops=10, nprocesses=16, verbose=False) self.assertEqual(options.sw_gbuf_bypass, (False, False, False), 'sw_gbuf_bypass') self.assertEqual(options.sw_solve_loopblocking, False, 'sw_solve_loopblocking') self.assertEqual(options.partition_hybrid, True, 'partition_hybrid') self.assertEqual(options.partition_batch, False, 'partition_batch') self.assertEqual(options.partition_ifmaps, False, 'partition_ifmaps') self.assertEqual(options.ntops, 10, 'ntops') self.assertEqual(options.nprocesses, 16, 'nprocesses') self.assertEqual(options.verbose, False, 'verbose')