def __init__(self, dg):
self.dg = BidirectionalDAG(dg)
self.might_merge = set(dg)
self.sig_replacements = {}
self.sig2ops = WeakKeyDefaultDict(WeakSet)
self.base2views = WeakKeyDefaultDict(WeakSet)
for op in self.dg.forward:
for s in op.all_signals:
self.sig2ops[s].add(op)
self.base2views[s.base].add(s)
# These variables will be initialized and used on each pass
self.dependents = None
self.only_merge_ops_with_view = None
self.merged = set()
self.merged_dependents = set()
self.opinfo = OpInfo()
def __init__(self, dg):
self.dg = BidirectionalDAG(dg)
self.might_merge = set(dg)
self.sig_replacements = {}
self.sig2ops = WeakKeyDefaultDict(WeakSet)
self.base2views = WeakKeyDefaultDict(WeakSet)
for op in self.dg.forward:
for s in op.all_signals:
self.sig2ops[s].add(op)
self.base2views[s.base].add(s)
# These variables will be initialized and used on each pass
self.dependents = None
self.only_merge_ops_with_view = None
self.merged = set()
self.merged_dependents = set()
self.opinfo = OpInfo()
class OpMergePass:
"""Manages a single optimization pass."""
def __init__(self, dg):
self.dg = BidirectionalDAG(dg)
self.might_merge = set(dg)
self.sig_replacements = {}
self.sig2ops = WeakKeyDefaultDict(WeakSet)
self.base2views = WeakKeyDefaultDict(WeakSet)
for op in self.dg.forward:
for s in op.all_signals:
self.sig2ops[s].add(op)
self.base2views[s.base].add(s)
# These variables will be initialized and used on each pass
self.dependents = None
self.only_merge_ops_with_view = None
self.merged = set()
self.merged_dependents = set()
self.opinfo = OpInfo()
def __call__(self, only_merge_ops_with_view):
"""Perform a single optimization pass.
Parameters
----------
only_merge_ops_with_view : bool
Limits operator merges to operators with views.
"""
# --- Initialize pass state
self.dependents = transitive_closure(self.dg.forward)
self.only_merge_ops_with_view = only_merge_ops_with_view
self.merged.clear()
self.merged_dependents.clear()
self.opinfo.clear()
# --- Do an optimization pass
self.perform_merges()
def perform_merges(self):
"""Go through all operators and merge them where possible.
Parameters
----------
only_merge_ops_with_view : bool
Limit merges to operators with views.
"""
# We go through the ops grouped by type as only ops with the same
# type can be merged.
by_type = groupby(self.might_merge, type)
# Note that we will stop once we merge any operator, so merges are
# performed on at most one type of operator per pass.
# The dependency graph and other information will be updated
# before merging other operator types.
# We go through ops in a heuristic order to reduce runtime
firstops = [ElementwiseInc, Copy, DotInc, SimNeurons]
sortedops = firstops + [op for op in by_type if op not in firstops]
for optype in sortedops:
if OpMerger.is_type_mergeable(optype):
self.perform_merges_for_subset(by_type[optype])
# If we're not only merging views, the memory layout changes
# and non-views are turned into views. In that case we need
# to update the signals the operators are referring to before
# trying to merge a different type of operators. Thus, we break
# the loop here.
if not self.only_merge_ops_with_view and len(self.merged) > 0:
break
def perform_merges_for_subset(self, subset):
"""Performs operator merges for a subset of operators.
Parameters
----------
subset : list
Subset of operators.
"""
by_view = groupby(subset, lambda op: self.opinfo.get(op).v_base)
if self.only_merge_ops_with_view:
if None in by_view:
# If an op has no views, v_base will be None.
# If we're only merging views, then we get rid of this subset.
del by_view[None]
for view_subset in by_view.values():
if len(view_subset) > 1:
self.perform_merges_for_view_subset(view_subset)
elif None in by_view and len(by_view[None]) > 1:
self.perform_merges_for_view_subset(by_view[None])
def perform_merges_for_view_subset(self, subset):
"""Perform merges for a subset of operators with the same view base.
Parameters
----------
subset : list
Subset of operators. These need to have the same view base (can be
None if it is None for all) for their first signal in
``all_signals``.
"""
# Sort to have sequential memory.
offsets = np.array(
[self.opinfo.get(op).v_offset for op in subset], dtype=rc.float_dtype
)
sort_indices = np.argsort(offsets)
offsets = offsets[sort_indices]
sorted_subset = [subset[i] for i in sort_indices]
for i, op in enumerate(sorted_subset):
if op in self.merged:
# Cannot merge merged operator again until dependency graph
# has been updated
continue
if op in self.merged_dependents or any(
o in self.merged for o in self.dependents[op]
):
continue
tomerge = OpsToMerge(
op, self.merged, self.merged_dependents, self.dependents
)
# For a merge to be possible the view of the next operator has to
# start where the view of op ends. Because we have sorted the
# operators by the start of their views we can do a binary search
# and potentially skip a number of operators at the beginning.
start = np.searchsorted(
offsets, offsets[i] + self.opinfo.get(op).v_size, side="left"
)
for op2 in sorted_subset[start:]:
if tomerge.not_sequential(op2):
# If this check is true the view of op2 does not
# immediately follow the view of the operators being
# merged. Because we iterate over the operators sorted by
# view offset there will be a gap between the end of the
# operators being merged and all remaining operators to
# loop over. With such a gap a merge is never possible and
# we can cut the loop short.
break
if op2 in self.merged:
continue
if OpMerger.is_mergeable(op2, tomerge):
tomerge.add(op2)
if len(tomerge.ops) > 1:
self.merge(tomerge)
elif self.only_merge_ops_with_view:
self.might_merge.remove(op)
def merge(self, tomerge):
"""Merges the given operators.
This method will also update ``op_replacements``, ``sig_replacements``,
and the internal list of merged operators to prevent further merges
on the same operators before all required operators and signals have
been replaced.
"""
merged_op, merged_sig = OpMerger.merge(tomerge.ops)
self.dg.merge(tomerge.ops, merged_op)
# Update tracking what has been merged and might be mergeable later
self.might_merge.difference_update(tomerge.ops)
self.might_merge.add(merged_op)
self.merged.update(tomerge.ops)
self.merged_dependents.update(tomerge.all_dependents)
for op in tomerge.ops:
# Mark all operators referencing the same signals as merged
# (even though they are not) to prevent them from getting
# merged before their signals have been updated.
for s in op.all_signals:
self.merged.update(self.sig2ops[s])
# Signal related updates
self.resolve_views_on_replaced_signals(merged_sig)
self.sig_replacements.update(merged_sig)
self.replace_op_signals(merged_sig)
self.update_signal_indexing(merged_op, merged_sig)
def resolve_views_on_replaced_signals(self, replaced_signals):
for sig in list(replaced_signals):
for view in self.base2views[sig]:
if view is sig:
continue
assert view.base is sig
base_replacement = replaced_signals[sig]
offset = view.offset
strides = tuple(
a // b * c
for a, b, c in zip_longest(
view.strides,
view.base.strides,
base_replacement.strides,
fillvalue=1,
)
)
if base_replacement.is_view:
offset += base_replacement.offset
base_replacement = base_replacement.base
buf = base_replacement.initial_value
initial_value = np.ndarray(
buffer=buf,
dtype=view.dtype,
shape=view.shape,
offset=offset,
strides=strides,
)
replaced_signals[view] = Signal(
initial_value,
name=view.name,
base=base_replacement,
readonly=view.readonly,
offset=offset,
)
def replace_op_signals(self, replaced_signals):
ops = (op for s in replaced_signals for op in self.sig2ops[s])
for v in ops:
# Update the op's signals
v.sets = [replaced_signals.get(s, s) for s in v.sets]
v.incs = [replaced_signals.get(s, s) for s in v.incs]
v.reads = [replaced_signals.get(s, s) for s in v.reads]
v.updates = [replaced_signals.get(s, s) for s in v.updates]
def update_signal_indexing(self, merged_op, replaced_signals):
for s in merged_op.all_signals:
self.sig2ops[s].add(merged_op)
if s.is_view:
self.base2views[s.base].add(s)
for from_sig, to_sig in replaced_signals.items():
self.sig2ops[to_sig] = self.sig2ops[from_sig]
if to_sig.is_view:
self.base2views[to_sig.base].add(to_sig)
def transitive_planner(op_list):
"""
Create merged execution plan through transitive closure construction.
This is something like a middle ground between `.greedy_planner` and
`.tree_planner`; it can improve simulation time over the greedy
planner, but comes with potentially significant build time increases.
Parameters
----------
op_list : list of `~nengo.builder.Operator`
All the ``nengo`` operators in a model (unordered)
Returns
-------
plan : list of tuple of `~nengo.builder.Operator`
Operators combined into mergeable groups and in execution order
"""
n_ele = len(op_list)
merge_groups = {}
dg = operator_dependency_graph(op_list)
op_codes = {op: np.uint32(i) for i, op in enumerate(op_list)}
dg = {op_codes[k]: set(op_codes[x] for x in v) for k, v in dg.items()}
op_codes = {} # so it will get garbage collected
dg = BidirectionalDAG(dg)
# fail fast here if the op graph has cycles
toposort(dg.forward)
builder_types = [builder.Builder.builders[type(op)] for op in op_list]
# sort operators by builder (we'll only be interested in one builder type
# at a time, because we can't merge operators between builder types anyway)
ops_by_type = defaultdict(set)
for i, op in enumerate(op_list):
ops_by_type[builder_types[i]].add(np.uint32(i))
# heuristic ordering for builder types (earlier items in the list will
# have higher priority, meaning that we will choose to merge those ops
# and potentially break lower-priority groups)
order = [
op_builders.SparseDotIncBuilder, op_builders.ElementwiseIncBuilder,
neuron_builders.SimNeuronsBuilder, process_builders.SimProcessBuilder,
op_builders.SimPyFuncBuilder, learning_rule_builders.SimOjaBuilder,
learning_rule_builders.SimVojaBuilder,
learning_rule_builders.SimBCMBuilder, op_builders.CopyBuilder,
op_builders.ResetBuilder, tensor_node.SimTensorNodeBuilder]
for builder_type in order:
if builder_type not in ops_by_type:
# no ops of this type in the model
continue
ops = ops_by_type[builder_type]
# compute transitive closure
trans = [None for _ in range(n_ele)]
transitive_closure_recurse(dg.forward, ops, trans, builder_type,
builder_types, {})
# reduce it to the elements we care about (ops of the current
# builder type)
trans = {i: v for i, v in enumerate(trans[:len(op_list)]) if i in ops}
while len(trans) > 0:
# find all the ops that have no downstream dependents
available = set(k for k, v in trans.items() if len(v) == 0)
# sort those ops into mergeable groups
groups = []
for op in available:
for g in groups:
if mergeable(op_list[op], (op_list[g[0]],)):
g.append(op)
break
else:
groups.append([op])
# merge the groups
for g in groups:
dg.merge(g, n_ele)
merge_groups[n_ele] = g
n_ele += 1
# remove those ops from the transitive closure
for op in available:
del trans[op]
# remove those ops from the transitive closure of upstream ops
# note: we first remove all the duplicate aliased transitive sets,
# to reduce the number of set operations we need to do
unique_trans = {id(v): v for v in trans.values()}
for t in unique_trans.values():
t -= available
# trans_reverse = [None for _ in range(n_ele)]
# transitive_closure_recurse(dg.backward, ops, trans_reverse,
# builder_type, builder_types, cache)
# trans_reverse = {i: v for i, v in
# enumerate(trans_reverse[:len(op_list)]) if i in ops}
# group = None
# for op in toposort(trans, trans_reverse):
# if group is None:
# group = [op]
# continue
#
# if mergeable(op_list[op], (op_list[group[0]],)) and all(
# x not in trans[op] for x in group):
# group.append(op)
# else:
# dg.merge(group, n_ele)
# merge_groups[n_ele] = group
# n_ele += 1
# group = [op]
#
# dg.merge(group, n_ele)
# merge_groups[n_ele] = group
# n_ele += 1
del ops_by_type[builder_type]
assert len(ops_by_type) == 0
# toposort the merged graph to come up with execution plan
plan = toposort(dg.forward)
plan = [tuple(op_list[x] for x in merge_groups[group]) for group in plan]
logger.debug("TRANSITIVE PLAN")
logger.debug("\n%s" * len(plan), *plan)
return plan
def __init__(self, network, dt=0.001, seed=None):
self.model = Model(
dt=float(dt),
label="Nengo RS model",
decoder_cache=get_default_decoder_cache(),
)
self.model.build(network)
signal_to_engine_id = {}
for signal_dict in self.model.sig.values():
for signal in signal_dict.values():
self.add_sig(signal_to_engine_id, signal)
x = SignalU64("step", 0)
signal_to_engine_id[self.model.step] = x
signal_to_engine_id[self.model.time] = SignalF64("time", 0.0)
self._sig_to_ngine_id = signal_to_engine_id
dg = BidirectionalDAG(operator_dependency_graph(self.model.operators))
toposorted_dg = toposort(dg.forward)
node_indices = {node: idx for idx, node in enumerate(toposorted_dg)}
ops = []
for op in toposorted_dg:
dependencies = [node_indices[node] for node in dg.backward[op]]
if isinstance(op, core_op.Reset):
ops.append(
Reset(
np.asarray(op.value, dtype=np.float64),
self.get_sig(signal_to_engine_id, op.dst),
dependencies,
))
elif isinstance(op, core_op.TimeUpdate):
ops.append(
TimeUpdate(
dt,
self.get_sig(signal_to_engine_id, self.model.step),
self.get_sig(signal_to_engine_id, self.model.time),
dependencies,
))
elif isinstance(op, core_op.ElementwiseInc):
ops.append(
ElementwiseInc(
self.get_sig(signal_to_engine_id, op.Y),
self.get_sig(signal_to_engine_id, op.A),
self.get_sig(signal_to_engine_id, op.X),
dependencies,
))
elif isinstance(op, core_op.Copy):
assert op.src_slice is None and op.dst_slice is None
ops.append(
Copy(
op.inc,
self.get_sig(signal_to_engine_id, op.src),
self.get_sig(signal_to_engine_id, op.dst),
dependencies,
))
elif isinstance(op, core_op.DotInc):
ops.append(
DotInc(
self.get_sig(signal_to_engine_id, op.Y),
self.get_sig(signal_to_engine_id, op.A),
self.get_sig(signal_to_engine_id, op.X),
dependencies,
))
elif isinstance(op, neurons.SimNeurons):
signals = SignalDict()
op.init_signals(signals)
ops.append(
SimNeurons(
self.dt,
op.neurons.step_math,
[signals[s]
for s in op.states] if hasattr(op, "states") else [],
self.get_sig(signal_to_engine_id, op.J),
self.get_sig(signal_to_engine_id, op.output),
dependencies,
))
elif isinstance(op, processes.SimProcess):
signals = SignalDict()
op.init_signals(signals)
shape_in = (0, ) if op.input is None else op.input.shape
shape_out = op.output.shape
rng = None
state = {k: signals[s] for k, s in op.state.items()}
step_fn = op.process.make_step(shape_in, shape_out, self.dt,
rng, state)
ops.append(
SimProcess(
op.mode == "inc",
lambda *args, step_fn=step_fn: np.asarray(
step_fn(*args), dtype=float),
self.get_sig(signal_to_engine_id, op.t),
self.get_sig(signal_to_engine_id, op.output),
None if op.input is None else self.get_sig(
signal_to_engine_id, op.input),
dependencies,
))
elif isinstance(op, core_op.SimPyFunc):
ops.append(
SimPyFunc(
lambda *args, op=op: np.asarray(op.fn(*args),
dtype=float),
self.get_sig(signal_to_engine_id, op.output),
None if op.t is None else self.get_sig(
signal_to_engine_id, op.t),
None if op.x is None else self.get_sig(
signal_to_engine_id, op.x),
dependencies,
))
else:
raise Exception(f"missing: {op}")
self.probe_mapping = {}
for probe in self.model.probes:
self.probe_mapping[probe] = Probe(
signal_to_engine_id[self.model.sig[probe]["in"]])
self._engine = Engine(list(signal_to_engine_id.values()), ops,
list(self.probe_mapping.values()))
self.data = SimData(self)
print("initialized")
self._engine.reset()
class OpMergePass:
def __init__(self, dg):
self.dg = BidirectionalDAG(dg)
self.might_merge = set(dg)
self.sig_replacements = {}
self.sig2ops = WeakKeyDefaultDict(WeakSet)
self.base2views = WeakKeyDefaultDict(WeakSet)
for op in self.dg.forward:
for s in op.all_signals:
self.sig2ops[s].add(op)
self.base2views[s.base].add(s)
# These variables will be initialized and used on each pass
self.dependents = None
self.only_merge_ops_with_view = None
self.merged = set()
self.merged_dependents = set()
self.opinfo = OpInfo()
def __call__(self, only_merge_ops_with_view):
"""Perform a single optimization pass.
Parameters
----------
only_merge_ops_with_view : bool
Limits operator merges to operators with views.
"""
# --- Initialize pass state
self.dependents = transitive_closure(self.dg.forward)
self.only_merge_ops_with_view = only_merge_ops_with_view
self.merged.clear()
self.merged_dependents.clear()
self.opinfo.clear()
# --- Do an optimization pass
self.perform_merges()
def perform_merges(self):
"""Go through all operators and merge them where possible.
Parameters
----------
only_merge_ops_with_view : bool
Limit merges to operators with views.
"""
# We go through the ops grouped by type as only ops with the same
# type can be merged.
by_type = groupby(self.might_merge, type)
# Note that we will stop once we merge any operator, so merges are
# performed on at most one type of operator per pass.
# The dependency graph and other information will be updated
# before merging other operator types.
# We go through ops in a heuristic order to reduce runtime
firstops = [ElementwiseInc, Copy, DotInc, SimNeurons]
sortedops = firstops + [op for op in by_type if op not in firstops]
for optype in sortedops:
if OpMerger.is_type_mergeable(optype):
self.perform_merges_for_subset(by_type[optype])
# If we're not only merging views, the memory layout changes
# and non-views are turned into views. In that case we need
# to update the signals the operators are referring to before
# trying to merge a different type of operators. Thus, we break
# the loop here.
if not self.only_merge_ops_with_view and len(self.merged) > 0:
break
def perform_merges_for_subset(self, subset):
"""Performs operator merges for a subset of operators.
Parameters
----------
subset : list
Subset of operators.
"""
by_view = groupby(subset, lambda op: self.opinfo[op].v_base)
if self.only_merge_ops_with_view:
if None in by_view:
# If an op has no views, v_base will be None.
# If we're only merging views, then we get rid of this subset.
del by_view[None]
for view_subset in by_view.values():
if len(view_subset) > 1:
self.perform_merges_for_view_subset(view_subset)
elif None in by_view and len(by_view[None]) > 1:
self.perform_merges_for_view_subset(by_view[None])
def perform_merges_for_view_subset(self, subset):
"""Perform merges for a subset of operators with the same view base.
Parameters
----------
subset : list
Subset of operators. These need to have the same view base (can be
None if it is None for all) for their first signal in
`all_signals`.
"""
# Sort to have sequential memory.
offsets = np.array([self.opinfo[op].v_offset for op in subset])
sort_indices = np.argsort(offsets)
offsets = offsets[sort_indices]
sorted_subset = [subset[i] for i in sort_indices]
for i, op1 in enumerate(sorted_subset):
if op1 in self.merged:
# Cannot merge merged operator again until dependency graph
# has been updated
continue
if op1 in self.merged_dependents or any(
op in self.merged for op in self.dependents[op1]):
continue
tomerge = OpsToMerge(op1, self.merged, self.merged_dependents,
self.dependents)
# For a merge to be possible the view of the next operator has to
# start where the view of op1 ends. Because we have sorted the
# operators by the start of their views we can do a binary search
# and potentially skip a number of operators at the beginning.
start = np.searchsorted(
offsets, offsets[i] + self.opinfo[op1].v_size, side='left')
for op2 in sorted_subset[start:]:
if tomerge.not_sequential(op2):
# If this check is true the view of op2 does not
# immediately follow the view of the operators being
# merged. Because we iterate over the operators sorted by
# view offset there will be a gap between the end of the
# operators being merged and all remaining operators to
# loop over. With such a gap a merge is never possible and
# we can cut the loop short.
break
if op2 in self.merged:
continue
if OpMerger.is_mergeable(op2, tomerge):
tomerge.add(op2)
if len(tomerge.ops) > 1:
self.merge(tomerge)
elif self.only_merge_ops_with_view:
self.might_merge.remove(op1)
def merge(self, tomerge):
"""Merges the given operators.
This method will also update ``op_replacements``, ``sig_replacements``,
and the internal list of merged operators to prevent further merges
on the same operators before all required operators and signals have
been replaced.
"""
merged_op, merged_sig = OpMerger.merge(tomerge.ops)
self.dg.merge(tomerge.ops, merged_op)
# Update tracking what has been merged and might be mergeable later
self.might_merge.difference_update(tomerge.ops)
self.might_merge.add(merged_op)
self.merged.update(tomerge.ops)
self.merged_dependents.update(tomerge.all_dependents)
for op in tomerge.ops:
# Mark all operators referencing the same signals as merged
# (even though they are not) to prevent them from getting
# merged before their signals have been updated.
for s in op.all_signals:
self.merged.update(self.sig2ops[s])
# Signal related updates
self.resolve_views_on_replaced_signals(merged_sig)
self.sig_replacements.update(merged_sig)
self.replace_op_signals(merged_sig)
self.update_signal_indexing(merged_op, merged_sig)
def resolve_views_on_replaced_signals(self, replaced_signals):
for sig in list(replaced_signals):
for view in self.base2views[sig]:
if view is sig:
continue
assert view.base is sig
base_replacement = replaced_signals[sig]
offset = view.offset
strides = tuple(
a // b * c for a, b, c in zip_longest(
view.strides,
view.base.strides,
base_replacement.strides,
fillvalue=1))
if base_replacement.is_view:
offset += base_replacement.offset
base_replacement = base_replacement.base
buf = base_replacement.initial_value
initial_value = np.ndarray(buffer=buf,
dtype=view.dtype,
shape=view.shape,
offset=offset,
strides=strides)
replaced_signals[view] = Signal(initial_value,
name=view.name,
base=base_replacement,
readonly=view.readonly,
offset=offset)
def replace_op_signals(self, replaced_signals):
ops = (op for s in replaced_signals for op in self.sig2ops[s])
for v in ops:
# Update the op's signals
v.sets = [replaced_signals.get(s, s) for s in v.sets]
v.incs = [replaced_signals.get(s, s) for s in v.incs]
v.reads = [replaced_signals.get(s, s) for s in v.reads]
v.updates = [replaced_signals.get(s, s) for s in v.updates]
def update_signal_indexing(self, merged_op, replaced_signals):
for s in merged_op.all_signals:
self.sig2ops[s].add(merged_op)
if s.is_view:
self.base2views[s.base].add(s)
for from_sig, to_sig in replaced_signals.items():
self.sig2ops[to_sig] = self.sig2ops[from_sig]
if to_sig.is_view:
self.base2views[to_sig.base].add(to_sig)