def main():
R = Region([4, 4], {'x': pygion.float64})
pygion.fill(R, 'x', 0)
# Create a partition of R.
colors = [2, 2]
transform = [[2, 0], [0, 2]]
extent = [2, 2]
P = Partition.restrict(R, colors, transform, extent)
# Again, with different parameters.
colors2 = [3]
transform2 = [[1], [2]]
extent2 = Domain([2, 2], [-1, -1])
P2 = Partition.restrict(R, colors2, transform2, extent2)
assert P.color_space.volume == 4
assert P2.color_space.volume == 3
# Grab a subregion of P.
R00 = P[0, 0]
print('Parent region has volume %s' % R.ispace.volume)
assert R.ispace.volume == 16
assert check_subregion(R00).get() == 4
for Rij in P:
assert check_subregion(Rij).get() == 4
assert check_subregion(P2[0]).get() == 1
assert check_subregion(P2[1]).get() == 4
assert check_subregion(P2[2]).get() == 2
def main():
R = Region([4, 4], {'point': pygion.int2d})
init_field(R)
P = Partition.restrict(R, [2, 2], np.eye(2) * 2, [2, 2])
Q = Partition.preimage(P, R, 'point', [2, 2])
assert P.color_space.volume == 4
assert P[0, 0].ispace.volume == 4
assert P[0, 1].ispace.volume == 4
assert P[1, 0].ispace.volume == 4
assert P[1, 1].ispace.volume == 4
assert Q[0, 0].ispace.volume == 8
assert Q[0, 1].ispace.volume == 2
assert Q[1, 0].ispace.volume == 5
assert Q[1, 1].ispace.volume == 1
def main():
R = Region([4, 4], {'rect': pygion.rect2d})
init_field(R)
P = Partition.restrict(R, [2, 2], np.eye(2) * 2, [2, 2])
Q = Partition.image(R, P, 'rect', [2, 2])
assert P.color_space.volume == 4
assert P[0, 0].ispace.volume == 4
assert P[0, 1].ispace.volume == 4
assert P[1, 0].ispace.volume == 4
assert P[1, 1].ispace.volume == 4
assert Q[0, 0].ispace.volume == 16
assert Q[0, 1].ispace.volume == 0
assert Q[1, 0].ispace.volume == 2
assert Q[1, 1].ispace.volume == 6
def make_colors_part(tiles):
colors = Region(tiles, {'rect': pygion.rect2d})
colors_part = Partition.restrict(colors, tiles, np.eye(2), [1, 1],
disjoint_complete)
return colors, colors_part
def main():
print_once('Running circuit_sparse.py')
conf = parse_args(pygion.input_args(True))
assert conf.num_pieces % conf.pieces_per_superpiece == 0, "pieces should be evenly distributed to superpieces"
conf.shared_nodes_per_piece = int(
math.ceil(conf.nodes_per_piece * conf.pct_shared_nodes / 100.0))
print_once(
"circuit settings: loops=%d prune=%d pieces=%d (pieces/superpiece=%d) nodes/piece=%d (nodes/piece=%d) wires/piece=%d pct_in_piece=%d seed=%d"
% (conf.num_loops, conf.prune, conf.num_pieces,
conf.pieces_per_superpiece, conf.nodes_per_piece,
conf.shared_nodes_per_piece, conf.wires_per_piece,
conf.pct_wire_in_piece, conf.random_seed))
num_pieces = conf.num_pieces
num_superpieces = conf.num_pieces // conf.pieces_per_superpiece
num_circuit_nodes = num_pieces * conf.nodes_per_piece
num_circuit_wires = num_pieces * conf.wires_per_piece
node = Fspace(
OrderedDict([
('node_cap', pygion.float32),
('leakage', pygion.float32),
('charge', pygion.float32),
('node_voltage', pygion.float32),
]))
wire = Fspace(
OrderedDict([
('in_ptr', pygion.int64),
('in_ptr_r', pygion.uint8),
('out_ptr', pygion.int64),
('out_ptr_r', pygion.uint8),
('inductance', pygion.float32),
('resistance', pygion.float32),
('wire_cap', pygion.float32),
] + [('current_%d' % i, pygion.float32)
for i in range(WIRE_SEGMENTS)] +
[('voltage_%d' % i, pygion.float32)
for i in range(WIRE_SEGMENTS - 1)]))
all_nodes = Region([num_circuit_nodes], node)
all_wires = Region([num_circuit_wires], wire)
node_size = np.dtype(list(
map(lambda x: (x[0], x[1].numpy_type), node.field_types.items())),
align=True).itemsize
wire_size = np.dtype(list(
map(lambda x: (x[0], x[1].numpy_type), wire.field_types.items())),
align=True).itemsize
print_once("Circuit memory usage:")
print_once(" Nodes : %10d * %4d bytes = %12d bytes" %
(num_circuit_nodes, node_size, num_circuit_nodes * node_size))
print_once(" Wires : %10d * %4d bytes = %12d bytes" %
(num_circuit_wires, wire_size, num_circuit_wires * wire_size))
total = ((num_circuit_nodes * node_size) + (num_circuit_wires * wire_size))
print_once(" Total %12d bytes" % total)
snpp = conf.shared_nodes_per_piece
pnpp = conf.nodes_per_piece - conf.shared_nodes_per_piece
pps = conf.pieces_per_superpiece
num_shared_nodes = num_pieces * snpp
privacy_coloring = Region([2], {'rect': pygion.rect1d})
np.copyto(privacy_coloring.rect,
np.array([(num_shared_nodes, num_circuit_nodes - 1),
(0, num_shared_nodes - 1)],
dtype=privacy_coloring.rect.dtype),
casting='no')
privacy_part = Partition.restrict(privacy_coloring, [2], np.eye(1), [1],
disjoint_complete)
all_nodes_part = Partition.image(all_nodes, privacy_part, 'rect', [2],
disjoint_complete)
all_private = all_nodes_part[0]
all_shared = all_nodes_part[1]
launch_domain = Ispace([num_superpieces])
private_part = Partition.restrict(all_private, launch_domain,
np.eye(1) * pnpp * pps,
Domain([pnpp * pps], [num_shared_nodes]),
disjoint_complete)
shared_part = Partition.restrict(all_shared, launch_domain,
np.eye(1) * snpp * pps, [snpp * pps],
disjoint_complete)
wires_part = Partition.equal(all_wires, launch_domain)
ghost_ranges = Region([num_superpieces],
OrderedDict([('rect', pygion.rect1d)]))
ghost_ranges_part = Partition.equal(ghost_ranges, launch_domain)
if _constant_time_launches:
c = Future(conf[0], value_type=Config)
index_launch(launch_domain, init_piece, ID, c, ghost_ranges_part[ID],
private_part[ID], shared_part[ID], all_shared,
wires_part[ID])
else:
for i in IndexLaunch(launch_domain):
init_piece(i, conf[0], ghost_ranges_part[i], private_part[i],
shared_part[i], all_shared, wires_part[i])
ghost_part = Partition.image(all_shared, ghost_ranges_part, 'rect',
launch_domain)
if _constant_time_launches:
index_launch(launch_domain, init_pointers, private_part[ID],
shared_part[ID], ghost_part[ID], wires_part[ID])
else:
for i in IndexLaunch(launch_domain):
init_pointers(private_part[i], shared_part[i], ghost_part[i],
wires_part[i])
steps = conf.steps
prune = conf.prune
num_loops = conf.num_loops + 2 * prune
trace = Trace()
for j in range(num_loops):
if j == prune:
pygion.execution_fence(block=True)
start_time = pygion.c.legion_get_current_time_in_nanos()
with trace:
if _constant_time_launches:
index_launch(launch_domain, calculate_new_currents, False,
steps, private_part[ID], shared_part[ID],
ghost_part[ID], wires_part[ID])
index_launch(launch_domain, distribute_charge,
private_part[ID], shared_part[ID], ghost_part[ID],
wires_part[ID])
index_launch(launch_domain, update_voltages, False,
private_part[ID], shared_part[ID])
else:
for i in IndexLaunch(launch_domain):
calculate_new_currents(False, steps, private_part[i],
shared_part[i], ghost_part[i],
wires_part[i])
for i in IndexLaunch(launch_domain):
distribute_charge(private_part[i], shared_part[i],
ghost_part[i], wires_part[i])
for i in IndexLaunch(launch_domain):
update_voltages(False, private_part[i], shared_part[i])
if j == num_loops - prune - 1:
pygion.execution_fence(block=True)
stop_time = pygion.c.legion_get_current_time_in_nanos()
sim_time = (stop_time - start_time) / 1e9
print_once('ELAPSED TIME = %7.3f s' % sim_time)
# Compute the floating point operations per second
num_circuit_nodes = conf.num_pieces * conf.nodes_per_piece
num_circuit_wires = conf.num_pieces * conf.wires_per_piece
# calculate currents
operations = num_circuit_wires * (WIRE_SEGMENTS * 6 +
(WIRE_SEGMENTS - 1) * 4) * conf.steps
# distribute charge
operations += (num_circuit_wires * 4)
# update voltages
operations += (num_circuit_nodes * 4)
# multiply by the number of loops
operations *= conf.num_loops
# Compute the number of gflops
gflops = (1e-9 * operations) / sim_time
print_once("GFLOPS = %7.3f GFLOPS" % gflops)