def _get_all_possible_recordable_variables(self):
variables = OrderedSet()
if isinstance(self._population._vertex, AbstractSpikeRecordable):
variables.add(SPIKES)
if isinstance(self._population._vertex, AbstractNeuronRecordable):
variables.update(
self._population._vertex.get_recordable_variables())
return variables
def test_update():
o = OrderedSet()
o.add(1)
o.add(2)
o.add(3)
o.update([3, 4, 5])
for item in (5, 4, 3, 2, 1):
assert o.pop() == item
with pytest.raises(KeyError):
o.pop()
def get_all_possible_recordable_variables(self):
""" All variables that could be recorded.
:rtype: set(str)
"""
variables = OrderedSet()
if isinstance(self.__vertex, AbstractSpikeRecordable):
variables.add(SPIKES)
if isinstance(self.__vertex, AbstractNeuronRecordable):
variables.update(self.__vertex.get_recordable_variables())
return variables
def _find_one_to_one_vertices(vertex, graph):
""" Find vertices which have one to one connections with the given\
vertex, and where their constraints don't force them onto\
different chips.
:param MachineGraph graph:
the graph to look for other one to one vertices
:param MachineVertex vertex:
the vertex to use as a basis for one to one connections
:return: set of one to one vertices
:rtype: set(MachineVertex)
"""
# Virtual vertices can't be forced on other chips
if isinstance(vertex, AbstractVirtual):
return []
found_vertices = OrderedSet()
vertices_seen = {vertex}
# look for one to ones leaving this vertex
outgoing = graph.get_edges_starting_at_vertex(vertex)
vertices_to_try = deque(
edge.post_vertex for edge in outgoing
if edge.post_vertex not in vertices_seen)
while vertices_to_try:
next_vertex = vertices_to_try.pop()
if next_vertex not in vertices_seen and \
not isinstance(next_vertex, AbstractVirtual):
vertices_seen.add(next_vertex)
if is_single(graph.get_edges_ending_at_vertex(next_vertex)):
found_vertices.add(next_vertex)
outgoing = graph.get_edges_starting_at_vertex(next_vertex)
vertices_to_try.extend(
edge.post_vertex for edge in outgoing
if edge.post_vertex not in vertices_seen)
# look for one to ones entering this vertex
incoming = graph.get_edges_ending_at_vertex(vertex)
vertices_to_try = deque(
edge.pre_vertex for edge in incoming
if edge.pre_vertex not in vertices_seen)
while vertices_to_try:
next_vertex = vertices_to_try.pop()
if next_vertex not in vertices_seen:
vertices_seen.add(next_vertex)
if is_single(graph.get_edges_starting_at_vertex(next_vertex)):
found_vertices.add(next_vertex)
incoming = graph.get_edges_ending_at_vertex(next_vertex)
vertices_to_try.extend(
edge.pre_vertex for edge in incoming
if edge.pre_vertex not in vertices_seen)
found_vertices.update(get_vertices_on_same_chip(vertex, graph))
return found_vertices
def _sort_vertices_for_one_to_one_connection(self, machine_graph,
same_chip_vertex_groups):
"""
:param machine_graph: the graph to place
:return: list of sorted vertices
"""
sorted_vertices = list()
found_list = set()
# order vertices based on constraint priority
vertices = sort_vertices_by_known_constraints(machine_graph.vertices)
for vertex in vertices:
if vertex not in found_list:
# vertices that are one to one connected with vertex and are
# not forced off chip
connected_vertices = self._find_one_to_one_vertices(
vertex, machine_graph)
# create list for each vertex thats connected haven't already
# been seen before
new_list = OrderedSet()
for found_vertex in connected_vertices:
if found_vertex not in found_list:
new_list.add(found_vertex)
# looks for vertices that have same chip constraints but not
# found by the one to one connection search.
same_chip_vertices = list()
for found_vertex in new_list:
for same_chip_constrained_vertex in \
same_chip_vertex_groups[found_vertex]:
if same_chip_constrained_vertex not in new_list:
same_chip_vertices.append(
same_chip_constrained_vertex)
# add these newly found vertices to the list
new_list.update(same_chip_vertices)
sorted_vertices.append(new_list)
found_list.update(new_list)
# locate vertices which have no output or input, and add them for
# placement
for vertex in vertices:
if vertex not in found_list:
sorted_vertices.append([vertex])
return sorted_vertices
def _clean_variables(self, variables):
""" Sorts out variables for processing usage
:param variables: list of variables names, or 'all', or single.
:return: ordered set of variables strings.
"""
# if variable is a base string, plonk into a array for ease of
# conversion
if isinstance(variables, string_types):
variables = [variables]
# if all are needed to be extracted, extract each and plonk into the
# neo block segment. ensures whatever was in variables stays in
# variables, regardless of all
if 'all' in variables:
variables = OrderedSet(variables)
variables.remove('all')
variables.update(self._get_all_recording_variables())
return variables
def get_vertices_on_same_chip(vertex, graph):
""" Get the vertices that must be on the same chip as the given vertex
:param AbstractVertex vertex: The vertex to search with
:param Graph graph: The graph containing the vertex
:rtype: set(AbstractVertex)
"""
# Virtual vertices can't be forced on different chips
if isinstance(vertex, AbstractVirtual):
return []
same_chip_as_vertices = OrderedSet()
for constraint in vertex.constraints:
if isinstance(constraint, SameChipAsConstraint):
same_chip_as_vertices.add(constraint.vertex)
same_chip_as_vertices.update(
edge.post_vertex for edge in graph.get_edges_starting_at_vertex(vertex)
if edge.traffic_type == EdgeTrafficType.SDRAM)
return same_chip_as_vertices
