Spinncer weight scale

c_common/front_end_common_lib/src/recording.c

@@ -195,8 +195,8 @@ bool recording_initialize(
                         sark_heap_max(sv->sdram_heap, 0));
                 return false;
             }
-            log_info("Allocated %u bytes for recording channel %u at 0x%08x",
-                    space, i, region->data);
+//            log_info("Allocated %u bytes for recording channel %u at 0x%08x",
+//                    space, i, region->data);
             if (recording_flags != NULL) {
                 *recording_flags = (*recording_flags | (1 << i));
             }

c_common/front_end_common_lib/src/simulation.c

@@ -197,15 +197,15 @@ static void simulation_control_scp_callback(uint mailbox, UNUSED uint port) {
             log_info("Calling pre-exit function");
             stored_exit_function();
         }
-        log_info("Exiting");
+//        log_info("Exiting");
         spin1_exit(0);
         break;
 
     case CMD_RUNTIME:
-        log_info("Setting the runtime of this model to %d starting at %d",
-                msg->arg1, msg->arg3);
-        log_info("Setting the flag of infinite run for this model to %d",
-                msg->arg2);
+        log_info("Setting the runtime of this model to %d starting at %d (flag %d)",
+                msg->arg1, msg->arg3, msg->arg2);
+//        log_info("Setting the flag of infinite run for this model to %d",
+//                msg->arg2);
 
         // resetting the simulation time pointer
         *pointer_to_simulation_time = msg->arg1;

spinn_front_end_common/interface/ds/data_type.py

@@ -18,6 +18,16 @@
 import numpy as np
 
 
+def _round_to_int(value):
+    """ Rounds a number to the closest integer
+    :param float value: The value to round
+    :rtype: int
+    """
+    if isinstance(value, int):
+        return value
+    return int(round(value))
+
+
 class DataType(Enum):
     """
     Supported data types.
@@ -49,7 +59,7 @@ class DataType(Enum):
              decimal.Decimal("1"),
              "B",
              False,
-             int,
+             _round_to_int,
              np.uint8,
              "8-bit unsigned integer")
     #: 16-bit unsigned integer
@@ -60,7 +70,7 @@ class DataType(Enum):
               decimal.Decimal("1"),
               "H",
               False,
-              int,
+              _round_to_int,
               np.uint16,
               "16-bit unsigned integer")
     #: 32-bit unsigned integer
@@ -71,7 +81,7 @@ class DataType(Enum):
               decimal.Decimal("1"),
               "I",
               False,
-              int,
+              _round_to_int,
               np.uint32,
               "32-bit unsigned integer")
     #: 64-bit unsigned integer
@@ -82,7 +92,7 @@ class DataType(Enum):
               decimal.Decimal("1"),
               "Q",
               False,
-              int,
+              _round_to_int,
               np.uint64,
               "64-bit unsigned integer")
     #: 8-bit signed integer
@@ -93,7 +103,7 @@ class DataType(Enum):
             decimal.Decimal("1"),
             "b",
             False,
-            int,
+            _round_to_int,
             np.int8,
             "8-bit signed integer")
     #: 16-bit signed integer
@@ -104,7 +114,7 @@ class DataType(Enum):
              decimal.Decimal("1"),
              "h",
              False,
-             int,
+             _round_to_int,
              np.int16,
              "16-bit signed integer")
     #: 32-bit signed integer
@@ -115,7 +125,7 @@ class DataType(Enum):
              decimal.Decimal("1"),
              "i",
              False,
-             int,
+             _round_to_int,
              np.int32,
              "32-bit signed integer")
     #: 64-bit signed integer
@@ -126,7 +136,7 @@ class DataType(Enum):
              decimal.Decimal("1"),
              "q",
              False,
-             int,
+             _round_to_int,
              np.int64,
              "64-bit signed integer")
     #: 8.8 unsigned fixed point number
@@ -402,6 +412,31 @@ def numpy_typename(self):
         """
         return self._numpy_typename
 
+    def closest_representable_value(self, value):
+        """
+        Returns the closest value to the given value that can be represented
+        by this type
+
+        :param value:
+        :type value: float or in
+        :rtype: float
+        """
+        return self.decode_from_int(self.encode_as_int(value))
+
+    def closest_representable_value_above(self, value):
+        """
+        Returns the closest value above the given value that can be
+        represented by this type.
+
+        :param value:
+        :type value: float or in
+        :rtype: float
+        """
+        closest_value = self.decode_from_int(self.encode_as_int(value))
+        if closest_value >= value:
+            return closest_value
+        return self.decode_from_int(self.encode_as_int(value)+1)
+
     def encode_as_int(self, value):
         """
         Returns the value as an integer, according to this type.
@@ -425,6 +460,15 @@ def encode_as_int(self, value):
             return self._force_cast(value)
         return value
 
+    def decode_from_int(self, value):
+        """
+        Decode a single value represented as an int according to this type.
+
+        :param int array:
+        :rtype: float or int
+        """
+        return value / float(self._scale)
+
     def encode_as_numpy_int(self, value):
         """
         Returns the value as a numpy integer, according to this type.

spinn_front_end_common/interface/interface_functions/placements_provenance_gatherer.py

@@ -17,7 +17,7 @@
 from spinn_utilities.log import FormatAdapter
 from spinn_utilities.progress_bar import ProgressBar
 from spinn_front_end_common.interface.provenance import (
-    AbstractProvidesProvenanceDataFromMachine)
+    AbstractProvidesProvenanceDataFromMachine, ProvenanceWriter)
 
 logger = FormatAdapter(logging.getLogger(__name__))
 
@@ -38,6 +38,7 @@ def placements_provenance_gatherer(n_placements, placements):
     # retrieve provenance data from any cores that provide data
     for placement in progress.over(placements):
         _add_placement_provenance(placement, errors)
+        _add_structured_provenance(placement, errors)
     if errors:
         logger.warning("Errors found during provenance gathering:")
         for error in errors:
@@ -50,11 +51,47 @@ def _add_placement_provenance(placement, errors):
     :param list(str) errors:
     """
     # retrieve provenance data from any cores that provide data
-    if isinstance(
-            placement.vertex, AbstractProvidesProvenanceDataFromMachine):
+    if isinstance(placement.vertex, AbstractProvidesProvenanceDataFromMachine):
         # get data
         try:
             placement.vertex.get_provenance_data_from_machine(placement)
 
         except Exception:  # pylint: disable=broad-except
             errors.append(traceback.format_exc())
+
+
+def _add_structured_provenance(placement, errors):
+    """
+    :param ~.Placement placement:
+    :param list(str) errors:
+    """
+    # Insert structured provenance data to database for cores that have data
+    if isinstance(placement.vertex, AbstractProvidesProvenanceDataFromMachine):
+
+        # Custom provenance presentation from SpiNNCer
+        # write provenance to file here in a useful way
+        columns = ['pop', 'label', 'min_atom', 'max_atom', 'no_atoms',
+                   'fixed_sdram', 'sdram_per_timestep']
+
+        pop = placement.vertex.label.split(":")[0]
+        fixed_sdram = placement.vertex.sdram_required.fixed
+        sdram_per_timestep = placement.vertex.sdram_required.per_timestep
+
+        label = placement.vertex.label
+        vertex_slice = placement.vertex.vertex_slice
+        max_atom = vertex_slice.hi_atom
+        min_atom = vertex_slice.lo_atom
+        no_atoms = vertex_slice.n_atoms
+
+        structured_provenance = [
+            pop, label, min_atom, max_atom, no_atoms,
+            fixed_sdram, sdram_per_timestep]
+
+        # get data
+        try:
+            with ProvenanceWriter() as db:
+                for n in range(len(columns)):
+                    db.insert_core(placement.x, placement.y, placement.p,
+                                   columns[n], structured_provenance[n])
+        except Exception:  # pylint: disable=broad-except
+            errors.append(traceback.format_exc())

spinn_front_end_common/interface/provenance/provenance_reader.py

@@ -147,7 +147,7 @@ def get_provenance_for_router(self, x, y):
             f"{ row[0] }: { row[1] }"
             for row in self.run_query(query, [int(x), int(y)]))
 
-    def get_cores_with_provenace(self):
+    def get_cores_with_provenance(self):
         """
         Gets the cores with provenance.
 
@@ -233,10 +233,10 @@ def demo():
                 print(row)
             print("\nCORES WITH LATE SPIKES:")
             print(pr.cores_with_late_spikes())
-            print("\nROUETER (0,0) PROVENANCE:")
+            print("\nROUTER (0,0) PROVENANCE:")
             print(pr.get_provenance_for_router(0, 0))
             print("\nCORES WITH PROVENACE")
-            print(pr.get_cores_with_provenace())
+            print(pr.get_cores_with_provenance())
 
 
 if __name__ == '__main__':

spinn_front_end_common/interface/provenance/provenance_writer.py

@@ -196,3 +196,42 @@ def insert_board_provenance(self, connections):
             VALUES (?, ?, ?)
             """, ((x, y, ipaddress)
                   for ((x, y), ipaddress) in connections.items()))
+
+    def insert_app_vertex(
+            self, label, the_type, description, the_value):
+        """
+        Inserts app level data into the app_vertex_provenance
+
+        :param str label: Label of the app_vertex
+        :param str the_type: Class of the app_vertex
+        :param str description: type of value
+        :param float the_value: data
+        """
+        self.execute(
+            """
+            INSERT OR IGNORE INTO app_vertex_provenance(
+                label, the_type, description, the_value)
+            VALUES(?, ?, ?, ?)
+            """,
+            [label, the_type, description, the_value])
+
+    def insert_lut(
+            self, pre_population, post_population, the_type, description,
+            the_value):
+        """
+        Inserts edge data into the lut_provenance
+        :param str pre_population: Name of the pre population / vertex
+        :param str post_population:  Name of the post population / vertex
+        :param str the_type: Class of the rule of the LUT
+        :param str description: type of value
+        :param float the_value: data
+        """
+        self.execute(
+            """
+            INSERT OR IGNORE INTO lut_provenance(
+                pre_population, post_population, the_type, description,
+                the_value)
+            VALUES(?, ?, ?, ?, ?)
+            """,
+            [pre_population, post_population, the_type, description,
+             the_value])

spinn_front_end_common/utilities/db.sql

@@ -225,3 +225,22 @@ CREATE TABLE IF NOT EXISTS boards_provenance(
     ip_addres STRING NOT NULL,
     ethernet_x INTEGER NOT NULL,
     ethernet_y INTEGER NOT NULL);
+
+---------------------------------------------------------------------
+-- A table app vertex provenance
+CREATE TABLE IF NOT EXISTS app_vertex_provenance(
+    app_vertex_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    label STRING NOT NULL,
+    the_type STRING NOT NULL,
+    description STRING NOT NULL,
+    the_value FLOAT NOT NULL);
+
+---------------------------------------------------------------------
+-- A table LUT provenance
+CREATE TABLE IF NOT EXISTS lut_provenance(
+    connector_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pre_population STRING NOT NULL,
+    post_population STRING NOT NULL,
+    the_type  STRING NOT NULL,
+    description STRING NOT NULL,
+    the_value FLOAT NOT NULL);

unittests/interface/provenance/test_provenance_database.py

@@ -185,6 +185,22 @@ def test_board(self):
         with ProvenanceWriter() as db:
             db.insert_board_provenance(data)
 
+    def test_app_vertex(self):
+        with ProvenanceWriter() as db:
+            db.insert_app_vertex("pop", "type", "description", 0.5)
+        with ProvenanceReader() as db:
+            data = db.run_query("Select * from app_vertex_provenance")
+        expected = [(1, 'pop', 'type', 'description', 0.5)]
+        self.assertListEqual(expected, data)
+
+    def test_lut(self):
+        with ProvenanceWriter() as db:
+            db.insert_lut("the pre", "A post", "OneToOne", "foo", 0.5)
+        with ProvenanceReader() as db:
+            data = db.run_query("Select * from lut_provenance")
+        expected = [(1, 'the pre', 'A post', 'OneToOne', 'foo', 0.5)]
+        self.assertListEqual(expected, data)
+
     def test_log(self):
         db1 = LogStoreDB()
         db2 = LogStoreDB()