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 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 setUp(self):
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=65536,
size_regf=64,
array_bus_width=float('inf'),
dram_bandwidth=float('inf'),
no_time_mux=False)
self.none_cstr = SchedulingConstraint()
part = PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM)
self.ifmap_layout = DataLayout(
frngs=(FmapRange((0, 0, 0, 0), (2, 4, 16, 16)), ),
regions=(self.resource.src_data_region, ),
parts=(part, ))
self.sched_seq = (2, 0, 0)
def test_args_kwargs(self):
''' Different ways to give args and kwargs. '''
dim = PhyDim2(4, 8)
origin = PhyDim2(1, 3)
dist = PhyDim2(1, 1)
type_ = NodeRegion.PROC
wtot = 6
wbeg = 5
nr0 = NodeRegion(dim=dim,
origin=origin,
dist=dist,
type=type_,
wtot=wtot,
wbeg=wbeg)
nr = NodeRegion(dim, origin, dist, type_, wtot, wbeg)
self.assertTupleEqual(nr, nr0)
nr = NodeRegion(dim,
origin,
wbeg=wbeg,
wtot=wtot,
type=type_,
dist=dist)
self.assertTupleEqual(nr, nr0)
nr = NodeRegion(dim, origin, dist, type=type_, wtot=wtot, wbeg=wbeg)
self.assertTupleEqual(nr, nr0)
def test_coordinate(self):
''' Get coordinate. '''
nr1 = NodeRegion(origin=PhyDim2(0, 0), dim=self.ps1.dim(),
type=NodeRegion.PROC)
nr2 = NodeRegion(origin=PhyDim2(0, 0), dim=self.ps2.dim(),
type=NodeRegion.PROC)
for ps, nr in zip([self.ps1, self.ps2], [nr1, nr2]):
coord_list = [ps.coordinate(nr, pidx) for pidx in ps.gen_pidx()]
self.assertEqual(len(coord_list), ps.size())
self.assertEqual(len(set(coord_list)), ps.size())
for coord in coord_list:
self.assertGreaterEqual(coord.h, 0)
self.assertGreaterEqual(coord.w, 0)
self.assertLess(coord.h, ps.dim().h)
self.assertLess(coord.w, ps.dim().w)
pidx = [PhyDim2(0, 0)] * pe.NUM
pidx[pe.OUTP] = PhyDim2(1, 1)
self.assertEqual(self.ps1.coordinate(nr1, pidx),
self.ps1.dim(pe.OFMP, pe.INPP)
* PhyDim2(1, 1))
self.assertEqual(self.ps2.coordinate(nr2, pidx),
self.ps2.dim(pe.OFMP, pe.BATP, pe.INPP)
* PhyDim2(1, 1))
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_iter_node(self):
''' Get node iterator. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
# No duplicates.
self.assertEqual(len(set(nr.iter_node())), nr.dim.size())
# All nodes is contained.
for c in nr.iter_node():
self.assertTrue(nr.contains_node(c))
def test_rel2abs_invalid_type(self):
''' Get rel2abs invalid type. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
with self.assertRaisesRegexp(TypeError, 'NodeRegion: .*PhyDim2.*'):
_ = nr.rel2abs((0, 0))
with self.assertRaisesRegexp(TypeError, 'NodeRegion: .*PhyDim2.*'):
_ = nr.rel2abs(1)
def test_rel2abs_not_in(self):
''' Get rel2abs not in. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
with self.assertRaisesRegexp(ValueError, 'NodeRegion: .*not in.*'):
_ = nr.rel2abs(PhyDim2(-1, 0))
with self.assertRaisesRegexp(ValueError, 'NodeRegion: .*not in.*'):
_ = nr.rel2abs(PhyDim2(0, 4))
def setUp(self):
self.ps1 = PartitionScheme(order=[pe.BATP, pe.OUTP, pe.OFMP, pe.INPP],
pdims=[(2, 3), (3, 1), (1, 5), (5, 2)])
self.ps2 = PartitionScheme(order=list(range(pe.NUM)),
pdims=[(2, 2), (5, 5), (3, 3), (1, 1)])
self.nr1 = NodeRegion(origin=PhyDim2(0, 0),
dim=self.ps1.dim(),
type=NodeRegion.PROC)
self.nr2 = NodeRegion(origin=PhyDim2(0, 0),
dim=self.ps2.dim(),
type=NodeRegion.PROC)
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 setUp(self):
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=65536, size_regf=64)
frmap = FmapRangeMap()
frmap.add(FmapRange((0, 0, 0, 0), (2, 4, 16, 16)), (PhyDim2(0, 0),))
self.ifmap_layout = DataLayout(origin=PhyDim2(0, 0), frmap=frmap,
type=NodeRegion.DATA)
def setUp(self):
self.proc_region = NodeRegion(dim=PhyDim2(2, 2),
origin=PhyDim2(0, 0),
type=NodeRegion.PROC)
self.dram_region = NodeRegion(dim=PhyDim2(2, 2),
origin=PhyDim2(0, 0),
type=NodeRegion.DRAM)
self.src_data_region = NodeRegion(dim=PhyDim2(2, 1),
origin=PhyDim2(0, 0),
type=NodeRegion.DRAM)
self.dst_data_region = NodeRegion(dim=PhyDim2(2, 1),
origin=PhyDim2(0, 1),
type=NodeRegion.DRAM)
def test_rel2abs(self):
''' Get rel2abs. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
self.assertTupleEqual(nr.rel2abs(PhyDim2(0, 3)), (1, 6))
self.assertTupleEqual(nr.rel2abs(PhyDim2(2, 1)), (3, 4))
self.assertSetEqual(
set(
nr.rel2abs(PhyDim2(h, w)) for h in range(nr.dim.h)
for w in range(nr.dim.w)), set(nr.iter_node()))
def test_contains_node(self):
''' Whether contains node. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
for h in range(1, 5):
for w in range(3, 7):
self.assertTrue(nr.contains_node(PhyDim2(h, w)))
num = 0
for h in range(-2, 10):
for w in range(-2, 10):
num += 1 if nr.contains_node(PhyDim2(h, w)) else 0
self.assertEqual(num, nr.dim.size())
def setUp(self):
# AlexNet.
self.convlayers = OrderedDict()
self.convlayers['conv1'] = ConvLayer(3, 96, 55, 11, 4)
self.convlayers['conv2'] = ConvLayer(48, 256, 27, 5)
self.convlayers['conv3'] = ConvLayer(256, 384, 13, 3)
self.convlayers['conv4'] = ConvLayer(192, 384, 13, 3)
self.convlayers['conv5'] = ConvLayer(192, 256, 13, 3)
self.fclayers = {}
self.fclayers['fc1'] = FCLayer(256, 4096, 6)
self.fclayers['fc2'] = FCLayer(4096, 4096)
self.fclayers['fc3'] = FCLayer(4096, 1000)
# LocalRegionLayer.
self.lrlayers = {}
self.lrlayers['pool1'] = PoolingLayer(64, 7, 2)
self.lrlayers['pool2'] = PoolingLayer(29, 13, 3)
self.lrlayers['pool3'] = PoolingLayer(32, 7, 2, strd=3)
self.lrlayers['lr1'] = LocalRegionLayer(32, 7, nreg=5, sreg=1)
self.lrlayers['lr2'] = LocalRegionLayer(32, 7, nreg=5, sreg=1, strd=2)
# Fake layers.
self.fake_layers = {}
# With irregular nifm/nofm.
self.fake_layers['IRR'] = ConvLayer(255, 383, 13, 3)
# With small numbers of fmaps.
self.fake_layers['SM'] = ConvLayer(5, 3, 13, 3)
# With large FIL height.
self.fake_layers['LGFIL'] = ConvLayer(64, 64, 13, 22)
# Resource.
self.resource = {}
proc_region = NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC)
data_region = NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DRAM)
# Eyeriss, ISSCC'16, JSSC'17.
self.resource['BASE'] = Resource(proc_region=proc_region,
dram_region=data_region,
src_data_region=data_region,
dst_data_region=data_region,
dim_array=PhyDim2(12, 14),
size_gbuf=108 * 1024,
size_regf=520,
array_bus_width=float('inf'),
dram_bandwidth=float('inf'),
no_time_mux=False)
def test_invalid_data_regions_len(self):
''' Invalid data_regions len. '''
with self.assertRaisesRegexp(ValueError, 'Resource: .*data_regions.*'):
_ = Resource(
proc_region=NodeRegion(dim=PhyDim2(2, 2),
origin=PhyDim2(0, 0),
type=NodeRegion.PROC),
data_regions=(NodeRegion(dim=PhyDim2(2, 1),
origin=PhyDim2(0, 0),
type=NodeRegion.DATA), ) * 3,
dim_array=PhyDim2(16, 16),
size_gbuf=131072,
size_regf=(512, ),
)
def test_mismatch_node_region(self):
''' Mismatched node region and part in constructor. '''
# Smaller node region. Invalid.
with self.assertRaisesRegexp(ValueError, 'BufShrScheme: .*region.*'):
_ = BufShrScheme(
NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC), self.ps1)
# Larger node region. Valid.
bufshr = BufShrScheme(
NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(100, 100),
type=NodeRegion.PROC), self.ps1)
self.assertTupleEqual(bufshr.dim(de.IFM), self.ps1.dim(pe.OUTP))
def test_invalid_proc_region(self):
''' Invalid proc_region. '''
with self.assertRaisesRegexp(TypeError, 'Resource: .*proc_region.*'):
_ = Resource(
proc_region=PhyDim2(2, 2),
data_regions=(NodeRegion(dim=PhyDim2(2, 1),
origin=PhyDim2(0, 0),
type=NodeRegion.DATA),
NodeRegion(dim=PhyDim2(2, 1),
origin=PhyDim2(0, 1),
type=NodeRegion.DATA)),
dim_array=PhyDim2(16, 16),
size_gbuf=131072,
size_regf=512,
)
def test_ofmap_local(self):
''' With locally stored ofmaps. '''
layer = self.layers['BASE']
part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP),
pdims=((4, 1), (1, 1), (1, 4), (1, 1)))
nr = NodeRegion(origin=PhyDim2(3, 3),
dim=part.dim(),
type=NodeRegion.PROC)
ilayout = self._make_data_layout(layer.nifm, layer.hifm, layer.wifm,
PhyDim2(-3, -3), (1, 1), (1, 1),
PhyDim2(1, 1))
olayout = DataLayout(frngs=(FmapRange(
(0, ) * 4,
(self.batch_size, layer.nofm, layer.hofm, layer.wofm)), ),
regions=(nr, ),
parts=(part, ))
filter_nodes = frozenset([PhyDim2(3, -3)])
nhops = partition.unit_nhops_to_proc_region(layer, self.batch_size, nr,
part, filter_nodes,
ilayout, olayout,
self.options['BASE'])
self.assertEqual(nhops[de.OFM], 0)
def test_invalid_wbeg_type(self):
''' Invalid wbeg type. '''
with self.assertRaisesRegexp(TypeError, 'NodeRegion: .*wbeg.*'):
_ = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC,
wbeg=1.3)
def test_lr_layer(self):
''' LR layers. '''
layer = self.layers['LR']
part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP),
pdims=((2, 1), (2, 4), (2, 2), (1, 1)))
nr = NodeRegion(origin=PhyDim2(0, 0),
dim=part.dim(),
type=NodeRegion.PROC)
ilayout = self._make_data_layout(layer.nifm, layer.hifm, layer.wifm,
PhyDim2(-3, -3), (1, 2), (4, 1),
PhyDim2(8, 4))
olayout = self._make_data_layout(layer.nofm, layer.hofm, layer.wofm,
PhyDim2(5, 5), (1, 1), (1, 2),
PhyDim2(2, 4))
filter_nodes = frozenset()
nhops = partition.unit_nhops_to_proc_region(layer, self.batch_size, nr,
part, filter_nodes,
ilayout, olayout,
self.options['BASE'])
true_nhops = self._true_unit_nhops(layer, nr, part, filter_nodes,
ilayout, olayout)
self.assertListEqual(nhops, true_nhops)
def setUp(self):
self.scheme = OrderedDict([
('cost', 9.876 + 1.234),
('time', 123.4),
('ops', 1234),
('num_nodes', 4),
('cost_op', 1.234),
('cost_access', 9.876),
('cost_noc', 0),
('cost_static', 0),
('proc_time', 59),
('bus_time', 40),
('dram_time', 120),
('access', [[2, 3, 4], [30, 40, 50], [400, 500, 600],
[5000, 6000, 7000]]),
('remote_gbuf_access', [0, 0, 0]),
('total_nhops', [123, 456, 789]),
('fetch', [[1, 2, 1], [3, 4, 5]]),
])
part = PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM)
self.ofmap_layout = DataLayout(
frngs=(FmapRange((0, 0, 0, 0), (2, 4, 16, 16)), ),
regions=(NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DRAM), ),
parts=(part, ))
self.sched_seq = (2, 0, 0)
def test_larger_wtot(self):
''' wtot > dim.w is valid. '''
nr = NodeRegion(dim=PhyDim2(4, 8),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC,
wtot=20)
self.assertEqual(nr.wtot, 20)
def test_projection_empty_region(self):
''' Get projection with empty region. '''
with self.assertRaisesRegex(ValueError, 'PartitionScheme: .*region.*'):
_ = self.ps1.projection(
NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(0, 0),
type=NodeRegion.DRAM))
def test_fc_layer(self):
''' FC layers. '''
layer = self.layers['FC']
part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP),
pdims=((8, 1), (1, 1), (1, 2), (1, 4)))
nr = NodeRegion(origin=PhyDim2(0, 0),
dim=part.dim(),
type=NodeRegion.PROC)
ilayout = self._make_data_layout(layer.nifm, layer.hifm, layer.wifm,
PhyDim2(-3, 10), (2, 4, 1, 2),
PhyDim2(4, 4))
olayout = self._make_data_layout(layer.nofm, layer.hofm, layer.wofm,
PhyDim2(1, 1), (2, 2, 1, 1),
PhyDim2(2, 2))
filter_nodes = [PhyDim2(0, 0), PhyDim2(0, 7)]
nhops = partition.part_layer_unit_nhops(layer, self.batch_size, part,
nr, filter_nodes, ilayout,
olayout, self.options['BASE'])
true_nhops = self._true_unit_nhops(layer, part, nr, filter_nodes,
ilayout, olayout)
self.assertListEqual(nhops, true_nhops)
def test_invalid_dist(self):
''' Invalid dist. '''
with self.assertRaisesRegexp(TypeError, 'NodeRegion: .*dist.*'):
_ = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
dist=(1, 1),
type=NodeRegion.PROC)
def test_origin(self):
''' Origin. '''
layer = self.layers['BASE']
part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP),
pdims=((1, 1), (1, 1), (1, 1), (1, 1)))
nr = NodeRegion(origin=PhyDim2(3, 3),
dim=part.dim(),
type=NodeRegion.PROC)
ilayout = self._make_data_layout(layer.nifm, layer.hifm, layer.wifm,
PhyDim2(-3, -3), (1, 1), (1, 1),
PhyDim2(1, 1))
olayout = self._make_data_layout(layer.nofm, layer.hofm, layer.wofm,
PhyDim2(3, 3), (1, 1), (1, 1),
PhyDim2(1, 1))
filter_nodes = frozenset([PhyDim2(3, -3)])
nhops_1 = partition.unit_nhops_to_proc_region(layer, self.batch_size,
nr, part, filter_nodes,
ilayout, olayout,
self.options['BASE'])
nr = NodeRegion(origin=PhyDim2(6, 6),
dim=part.dim(),
type=NodeRegion.PROC)
ilayout = self._make_data_layout(layer.nifm, layer.hifm, layer.wifm,
PhyDim2(-6, -6), (1, 1), (1, 1),
PhyDim2(1, 1))
olayout = self._make_data_layout(layer.nofm, layer.hofm, layer.wofm,
PhyDim2(6, 6), (1, 1), (1, 1),
PhyDim2(1, 1))
filter_nodes = frozenset([PhyDim2(6, -6)])
nhops_2 = partition.unit_nhops_to_proc_region(layer, self.batch_size,
nr, part, filter_nodes,
ilayout, olayout,
self.options['BASE'])
self.assertListEqual(nhops_2, [n * 2 for n in nhops_1])
def test_valid_args(self):
''' Valid arguments. '''
nr = NodeRegion(dim=PhyDim2(4, 4),
origin=PhyDim2(1, 3),
type=NodeRegion.PROC)
self.assertTupleEqual(nr.dim, (4, 4), 'dim')
self.assertTupleEqual(nr.origin, (1, 3), 'origin')
self.assertEqual(nr.type, NodeRegion.PROC, 'type')
def setUp(self):
self.network = Network('test_net')
self.network.set_input(InputLayer(3, 224))
self.network.add('c1', ConvLayer(3, 64, 224, 3))
self.network.add('p1', PoolingLayer(64, 7, 32), prevs='c1')
self.network.add('p2', PoolingLayer(64, 7, 32), prevs='c1')
self.network.add('f1', FCLayer(64, 1000, 7), prevs=['p1', 'p2'])
self.batch_size = 4
self.input_layout = partition.get_ofmap_layout(
self.network.input_layer(), self.batch_size,
PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM),
NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(2, 1),
type=NodeRegion.DATA))
self.c1res = SchedulingResult(
dict_loop=OrderedDict([('cost', 1.), ('time', 2.), ('ops', 4.),
('access', [[7, 8, 9]] * me.NUM),
]),
dict_part=OrderedDict([('cost', 0.5), ('total_nhops', [4, 5, 6]),
('num_nodes', 4),
]),
ofmap_layout=partition.get_ofmap_layout(
self.network['c1'], self.batch_size,
PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM),
NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2),
type=NodeRegion.DATA)))
self.pres = SchedulingResult(
dict_loop=OrderedDict([('cost', 0.1), ('time', 0.05), ('ops', 0.1),
('access', [[.7, .8, .9]] * me.NUM),
]),
dict_part=OrderedDict([('cost', 0.5), ('total_nhops', [.4, .5, .6]),
('num_nodes', 2),
]),
ofmap_layout=partition.get_ofmap_layout(
self.network['p1'], self.batch_size,
PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM),
NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2),
type=NodeRegion.DATA)))
self.dtfl = NNDataflowScheme(self.network, self.input_layout)
self.dtfl['c1'] = self.c1res
self.dtfl['p1'] = self.pres
self.dtfl['p2'] = self.pres