Пример #1
0
    def reset(self):
        """ Resets the buffered regions to start transmitting from the\
            beginning of its expected regions and clears the buffered out data\
            files
        """
        # reset buffered out
        self._received_data = BufferedReceivingData()

        # rewind buffered in
        for vertex in self._sender_vertices:
            for region in vertex.get_regions():
                vertex.rewind(region)
Пример #2
0
    def __init__(self, placements, tags, transceiver, write_reload_files,
                 application_folder_path):
        """

        :param placements: The placements of the vertices
        :type placements:\
                    :py:class:`pacman.model.placements.placements.Placements`
        :param report_states: the booleans saying what reports are needed
        :type report_states: XXXXXXXXXXX
        :param tags: The tags assigned to the vertices
        :type tags: :py:class:`pacman.model.tags.tags.Tags`
        :param transceiver: The transceiver to use for sending and receiving\
                    information
        :type transceiver: :py:class:`spinnman.transceiver.Transceiver`
        """

        self._placements = placements
        self._tags = tags
        self._transceiver = transceiver

        # params used for reload purposes
        self._write_reload_files = write_reload_files
        self._application_folder_path = application_folder_path
        self._reload_buffer_file = dict()
        self._reload_buffer_file_paths = dict()

        # Set of (ip_address, port) that are being listened to for the tags
        self._seen_tags = set()

        # Set of vertices with buffers to be sent
        self._sender_vertices = set()

        # Dictionary of sender vertex -> buffers sent
        self._sent_messages = dict()

        # storage area for received data from cores
        self._received_data = BufferedReceivingData()

        # Lock to avoid multiple messages being processed at the same time
        self._thread_lock_buffer_out = threading.Lock()
        self._thread_lock_buffer_in = threading.Lock()

        self._finished = False