Power direct2

.ratexcludes

@@ -17,3 +17,4 @@
 **/PACMAN/**
 **/DataSpecification/**
 **/spalloc/**
+**/unittests/**/*.rpt

spinn_front_end_common/data/fec_data_view.py

@@ -74,6 +74,7 @@ class _FecDataModel(object):
         "_notification_protocol",
         "_max_run_time_steps",
         "_monitor_map",
+        "_reset_number",
         "_run_number",
         "_run_step",
         "_simulation_time_step_ms",
@@ -111,6 +112,7 @@ def _clear(self):
         self._n_boards_required = None
         self._n_chips_required = None
         self._none_labelled_edge_count = 0
+        self._reset_number = 0
         self._run_number = None
         self._simulation_time_step_ms = None
         self._simulation_time_step_per_ms = None
@@ -414,6 +416,50 @@ def has_time_scale_factor(cls):
         """
         return cls.__fec_data._time_scale_factor is not None
 
+    #  reset number
+
+    @classmethod
+    def get_reset_number(cls):
+        """
+        Get the number of times a reset has happened.
+
+        Only counts the first reset after each run.
+
+        So resets that are first soft then hard are ignored.
+        Double reset calls without a run and resets before run are ignored.
+
+        Reset numbers start at zero
+
+        :return:
+        :raises ~spinn_utilities.exceptions.SpiNNUtilsException:
+            If the run_number is currently unavailable
+        """
+        if cls.__fec_data._reset_number is None:
+            raise cls._exception("run_number")
+        return cls.__fec_data._reset_number
+
+    @classmethod
+    def get_reset_str(cls):
+        """
+        Get the number of times a reset has happene as a string. Zero as ""
+
+        Only counts the first reset after each run.
+
+        So resets that are first soft then hard are ignored.
+        Double reset calls without a run and resets before run are ignored.
+
+        Reset numbers start at zero
+
+        :raises ~spinn_utilities.exceptions.SpiNNUtilsException:
+            If the run_number is currently unavailable
+        """
+        if cls.__fec_data._reset_number is None:
+            raise cls._exception("run_number")
+        if cls.__fec_data._reset_number:
+            return str(cls.__fec_data._reset_number)
+        else:
+            return ""
+
     #  run number
 
     @classmethod

spinn_front_end_common/data/fec_data_writer.py

@@ -85,13 +85,17 @@ def finish_run(self):
 
     @overrides(PacmanDataWriter._hard_reset)
     def _hard_reset(self):
+        if self.is_ran_last():
+            self.__fec_data._reset_number += 1
         PacmanDataWriter._hard_reset(self)
         SpiNNManDataWriter._local_hard_reset(self)
         self.__fec_data._hard_reset()
         self.__create_run_dir_path()
 
     @overrides(PacmanDataWriter._soft_reset)
     def _soft_reset(self):
+        if self.is_ran_last():
+            self.__fec_data._reset_number += 1
         PacmanDataWriter._soft_reset(self)
         SpiNNManDataWriter._local_soft_reset(self)
         self.__fec_data._soft_reset()

spinn_front_end_common/interface/abstract_spinnaker_base.py

@@ -68,6 +68,8 @@
     AbstractVertexWithEdgeToDependentVertices,
     AbstractCanReset)
 from spinn_front_end_common.interface.buffer_management import BufferManager
+from spinn_front_end_common.interface.buffer_management.storage_objects \
+    import BufferDatabase
 from spinn_front_end_common.interface.config_handler import ConfigHandler
 from spinn_front_end_common.interface.interface_functions import (
     application_finisher, application_runner,
@@ -98,7 +100,7 @@
     host_no_bitfield_router_compression import (
         ordered_covering_compression, pair_compression)
 from spinn_front_end_common.interface.provenance import (
-    FecTimer, ProvenanceWriter, TimerCategory, TimerWork)
+    FecTimer, GlobalProvenance, TimerCategory, TimerWork)
 from spinn_front_end_common.interface.splitter_selectors import (
     splitter_selector)
 from spinn_front_end_common.interface.java_caller import JavaCaller
@@ -109,12 +111,12 @@
     memory_map_on_host_chip_report, network_specification,
     router_collision_potential_report,
     routing_table_from_machine_report, tags_from_machine_report,
-    write_json_machine, write_json_placements,
+    write_chip_active_report, write_json_machine, write_json_placements,
     write_json_routing_tables, drift_report)
 from spinn_front_end_common.utilities.iobuf_extractor import IOBufExtractor
 from spinn_front_end_common.utilities.utility_objs import ExecutableType
 from spinn_front_end_common.utility_models import (
-    DataSpeedUpPacketGatherMachineVertex)
+    DataSpeedUpPacketGatherMachineVertex,  ChipPowerMonitorMachineVertex)
 from spinn_front_end_common.utilities.report_functions.reports import (
     generate_comparison_router_report, partitioner_report,
     placer_reports_with_application_graph,
@@ -439,6 +441,9 @@ def __run(self, run_time, sync_time):
 
             self._do_mapping(total_run_time)
 
+        if not self._data_writer.is_ran_last():
+            self._execute_record_core_names()
+
         # Check if anything has per-timestep SDRAM usage
         is_per_timestep_sdram = self._is_per_timestep_sdram()
 
@@ -721,7 +726,7 @@ def _get_machine(self):
     def _create_version_provenance(self):
         """ Add the version information to the provenance data at the start.
         """
-        with ProvenanceWriter() as db:
+        with GlobalProvenance() as db:
             db.insert_version("spinn_utilities_version", spinn_utils_version)
             db.insert_version("spinn_machine_version", spinn_machine_version)
             db.insert_version("spalloc_version", spalloc_version)
@@ -888,6 +893,12 @@ def _do_placer(self, system_placements):
         raise ConfigurationException(
             f"Unexpected cfg setting placer: {name}")
 
+    def _execute_record_core_names(self):
+        with FecTimer(
+                "Record core names to databse", TimerWork.REPORT):
+            with BufferDatabase() as db:
+                db.store_vertex_labels()
+
     def _execute_system_multicast_routing_generator(self):
         """
         Runs, times and logs the SystemMulticastRoutingGenerator is required
@@ -2271,23 +2282,44 @@ def _print_iobuf(errors, warnings):
         for error in errors:
             logger.error(error)
 
+    def _execute_prepare_chip_power(self):
+        with FecTimer("Prepare Chip Power", TimerWork.REPORT) as timer:
+            if timer.skip_if_cfg_false("Reports", "write_energy_report"):
+                return
+            if timer.skip_if_virtual_board():
+                return
+            db = BufferDatabase()
+            db.store_chip_power_monitors(ChipPowerMonitorMachineVertex)
+            db.close()
+
+    def _report_chip_active(self):
+        with FecTimer("Prepare Chip Power", TimerWork.REPORT) as timer:
+            if timer.skip_if_cfg_false("Reports", "write_energy_report"):
+                return
+            if timer.skip_if_virtual_board():
+                return
+            write_chip_active_report()
+
+    def _do_end_of_run(self):
+        if not self._data_writer.is_ran_last():
+            return
+        self._execute_prepare_chip_power()
+        self._report_chip_active()
+
     def reset(self):
         """ Code that puts the simulation back at time zero
         """
-        FecTimer.start_category(TimerCategory.RESETTING)
         if not self._data_writer.is_ran_last():
             if not self._data_writer.is_ran_ever():
                 logger.error("Ignoring the reset before the run")
             else:
                 logger.error("Ignoring the repeated reset call")
             return
 
+        FecTimer.start_category(TimerCategory.RESETTING)
         logger.info("Resetting")
 
-        # rewind the buffers from the buffer manager, to start at the beginning
-        # of the simulation again and clear buffered out
-        if self._data_writer.has_buffer_manager():
-            self._data_writer.get_buffer_manager().reset()
+        self._do_end_of_run()
 
         if self._data_writer.get_user_accessed_machine():
             logger.warning(
@@ -2297,6 +2329,11 @@ def reset(self):
         else:
             self._data_writer.soft_reset()
 
+        # rewind the buffers from the buffer manager, to start at the beginning
+        # of the simulation again and clear buffered out
+        if self._data_writer.has_buffer_manager():
+            self._data_writer.get_buffer_manager().reset()
+
         # Reset the graph off the machine, to set things to time 0
         self.__reset_graph_elements()
         FecTimer.end_category(TimerCategory.RESETTING)
@@ -2368,6 +2405,8 @@ def stop(self):
                 set_config("Reports", "read_provenance_data", "True")
                 self._do_read_provenance()
 
+            self._do_end_of_run()
+
         except Exception as e:
             self._recover_from_error(e)
             self.write_errored_file()

spinn_front_end_common/interface/buffer_management/buffer_manager.py

@@ -91,9 +91,6 @@ class BufferManager(object):
         # Dictionary of sender vertex -> buffers sent
         "_sent_messages",
 
-        # storage area for received data from cores
-        "_db",
-
         # Lock to avoid multiple messages being processed at the same time
         "_thread_lock_buffer_out",
 
@@ -121,9 +118,6 @@ def __init__(self):
         # Dictionary of sender vertex -> buffers sent
         self._sent_messages = dict()
 
-        # storage area for received data from cores
-        self._db = BufferDatabase()
-
         # Lock to avoid multiple messages being processed at the same time
         self._thread_lock_buffer_out = threading.RLock()
         self._thread_lock_buffer_in = threading.RLock()
@@ -303,9 +297,6 @@ def reset(self):
             beginning of its expected regions and clears the buffered out\
             data files.
         """
-        #
-        self._db.reset()
-
         # rewind buffered in
         for vertex in self._sender_vertices:
             for region in vertex.get_regions():
@@ -328,7 +319,8 @@ def clear_recorded_data(self, x, y, p, recording_region_id):
         :param int p: placement p coordinate
         :param int recording_region_id: the recording region ID
         """
-        self._db.clear_region(x, y, p, recording_region_id)
+        with BufferDatabase() as db:
+            db.clear_region(x, y, p, recording_region_id)
 
     def _create_message_to_send(self, size, vertex, region):
         """ Creates a single message to send with the given boundaries.
@@ -575,14 +567,15 @@ def __python_get_data_for_placements(self, recording_placements):
         """
         :param ~pacman.model.placements.Placements recording_placements:
             Where to get the data from.
-       """
+        """
         # get data
         progress = ProgressBar(
             len(recording_placements),
             "Extracting buffers from the last run")
 
-        for placement in progress.over(recording_placements):
-            self._retreive_by_placement(placement)
+        with BufferDatabase() as db:
+            for placement in progress.over(recording_placements):
+                self._retreive_by_placement(db, placement)
 
     def get_data_by_placement(self, placement, recording_region_id):
         """ Get the data container for all the data retrieved\
@@ -602,12 +595,14 @@ def get_data_by_placement(self, placement, recording_region_id):
                 "so no data read".format(placement.vertex))
         with self._thread_lock_buffer_out:
             # data flush has been completed - return appropriate data
-            return self._db.get_region_data(
-                placement.x, placement.y, placement.p, recording_region_id)
+            with BufferDatabase() as db:
+                return db.get_region_data(
+                    placement.x, placement.y, placement.p, recording_region_id)
 
-    def _retreive_by_placement(self, placement):
+    def _retreive_by_placement(self, db, placement):
         """ Retrieve the data for a vertex; must be locked first.
 
+        :param db BufferDatabase: dtabase to store into
         :param ~pacman.model.placements.Placement placement:
             the placement to get the data from
         :param int recording_region_id: desired recording data region
@@ -623,7 +618,7 @@ def _retreive_by_placement(self, placement):
             size, addr, missing = sizes_and_addresses[region]
             data = self._request_data(
                 placement.x, placement.y, addr, size)
-            self._db.store_data_in_region_buffer(
+            db.store_data_in_region_buffer(
                 placement.x, placement.y, placement.p, region, missing, data)
 
     def _get_region_information(self, addr, x, y, p):

spinn_front_end_common/interface/buffer_management/storage_objects/__init__.py

@@ -15,6 +15,6 @@
 
 from .buffered_sending_region import BufferedSendingRegion
 from .buffers_sent_deque import BuffersSentDeque
-from .sqllite_database import BufferDatabase
+from .buffer_database import BufferDatabase
 
 __all__ = ["BufferedSendingRegion", "BuffersSentDeque", "BufferDatabase"]