Improve C use

Thanks @neworderofjamie

spinnaker_components/common/input_filtering.c

@@ -229,31 +229,27 @@ FilterInit filter_types[] = {
  * `routes` should be an array of `_if_routes` preceded with a single word
  * indicating the number of entries.
  */
-typedef struct _i_entry
-{
-  uint32_t key, mask, dimension_mask, filter_index;
-} i_entry_t;
 
 void input_filtering_get_routes(if_collection_t *filters,
                                 if_routing_table_t *routing_table,
-                                uint32_t *routes)
+                                filter_routes_t *routes)
 {
-  filter_arg_t args[] = {{filters, routes}};
+  filter_arg_t args[] = {{.filters = filters, .routes = routes}};
   input_filter_build_combined_routes(
     routing_table, sizeof(args) / sizeof(filter_arg_t), args);
 }
 
 void input_filter_build_combined_routes(
     if_routing_table_t *routing_table,
-    unsigned int n,
+    const unsigned int n,
     filter_arg_t *args
 )
 {
   // Compute the number of routing table entries
   routing_table->n_routes = 0;
   for (unsigned int i = 0; i < n; i++)
   {
-    routing_table->n_routes += args[i].data[0];
+    routing_table->n_routes += args[i].routes->n_routes;
   }
 
   debug("Loading %u filter routes\n", routing_table->n_routes);
@@ -267,23 +263,32 @@ void input_filter_build_combined_routes(
 
   for (unsigned int i = 0; i < n; i++)
   {
+    debug("Filter block %u\n", n);
     if_collection_t *filters = args[i].filters;
-    i_entry_t *entries = (i_entry_t *) &args[i].data[1];
 
-    for (unsigned int j = 0; j < args[i].data[0]; j++)
+    for (unsigned int j = 0; j < args[i].routes->n_routes; j++)
     {
       // Get the entry in the table
       if_route_t *route = &(routing_table->routes[current_entry]);
-      current_entry++;
-      i_entry_t entry = entries[j];
+      const input_filter_route_t *entry = &args[i].routes->routes[j];
 
       // Copy across the key, mask and dimension mask
-      route->key = entry.key;
-      route->mask = entry.mask;
-      route->dimension_mask = entry.dimension_mask;
+      route->key = entry->key;
+      route->mask = entry->mask;
+      route->dimension_mask = entry->dimension_mask;
 
       // Get a pointer to the intended filter
-      route->filter = &filters->filters[entry.filter_index];
+      route->filter = &filters->filters[entry->filter_index];
+
+      debug("\t[%u] key=%032x, mask=%032x, dmask=%032x -> %u\n",
+            current_entry,
+            entry->key,
+            entry->mask,
+            entry->dimension_mask,
+            entry->filter_index);
+
+      // Point to the next entry
+      current_entry++;
     }
   }
 }

spinnaker_components/common/input_filtering.h

@@ -257,10 +257,22 @@ static inline void input_filtering_step(
  * `routes` should be an array of `_if_routes` preceded with a single word
  * indicating the number of entries.
  */
+typedef struct
+{
+  uint32_t key, mask, dimension_mask, filter_index;
+} input_filter_route_t;
+
+typedef struct
+{
+  uint32_t n_routes;
+  input_filter_route_t routes[];
+} filter_routes_t;
+
 void input_filtering_get_routes(
     if_collection_t *filters,
     if_routing_table_t *routing_table,
-    uint32_t *routes);
+    filter_routes_t *routes
+);
 
 /* Copy in a set of filters.
  *
@@ -274,14 +286,14 @@ void input_filtering_get_filters(
     uint32_t *data,
     value_t **filter_output_array);
 
+/* Copy multiple sets of filter routes into a single routing table.
+ */
 typedef struct _filter_arg
 {
   if_collection_t *filters;
-  uint32_t *data;
+  filter_routes_t *routes;
 } filter_arg_t;
 
-/* Copy multiple sets of filter routes into a single routing table.
- */
 void input_filter_build_combined_routes(
   if_routing_table_t *routing_table, unsigned int n, filter_arg_t *args
 );

spinnaker_components/ensemble/ensemble.c

@@ -693,8 +693,12 @@ void c_main(void)
                               ensemble.learnt_input_local);
 
   filter_arg_t sliced_inputs[] = {
-    {&input_filters, region_start(INPUT_ROUTING_REGION, address)},
-    {&learnt_encoder_filters, region_start(LEARNT_ENCODER_ROUTING_REGION, address)},
+    {.filters = &input_filters,
+     .routes = (filter_routes_t *) region_start(INPUT_ROUTING_REGION, address)
+    },
+    {.filters = &learnt_encoder_filters,
+     .routes = (filter_routes_t *) region_start(LEARNT_ENCODER_ROUTING_REGION, address)
+    },
   };
   input_filter_build_combined_routes(
     &filter_routing_sliced_inputs,
@@ -703,8 +707,12 @@ void c_main(void)
   );
 
   filter_arg_t unsliced_inputs[] = {
-    {&inhibition_filters, region_start(INHIB_ROUTING_REGION, address)},
-    {&modulatory_filters, region_start(MODULATORY_ROUTING_REGION, address)},
+    {.filters = &inhibition_filters,
+     .routes = (filter_routes_t *) region_start(INHIB_ROUTING_REGION, address)
+    },
+    {.filters = &modulatory_filters,
+     .routes = (filter_routes_t *) region_start(MODULATORY_ROUTING_REGION, address)
+    },
   };
   input_filter_build_combined_routes(
     &filter_routing_unsliced_inputs,

spinnaker_components/filter/filter.c

@@ -175,7 +175,8 @@ void c_main(void)
 
   // Prepare the filters for receiving packets
   input_filtering_get_filters(&filters, region_start(3, address), NULL);
-  input_filtering_get_routes(&filters, &filter_routing, region_start(4, address));
+  input_filtering_get_routes(&filters, &filter_routing,
+                             (filter_routes_t *) region_start(4, address));
   input_filtering_initialise_output(&filters, params.input_size);
 
   // Multicast packet queue

spinnaker_components/sdp_tx/sdp_tx_main.c

@@ -65,7 +65,8 @@ void mcpl_callback(uint key, uint payload) {
 void c_main(void) {
   address_t address = system_load_sram();
   input_filtering_get_filters(&g_input, region_start(2, address), NULL);
-  input_filtering_get_routes(&g_input, &filter_routing, region_start(3, address));
+  input_filtering_get_routes(&g_input, &filter_routing,
+                             (filter_routes_t *) region_start(3, address));
   if (!data_system(region_start(1, address)))
   {
     io_printf(IO_BUF, "[Tx] Failed to initialise.\n");

spinnaker_components/value_sink/value_sink.c

@@ -109,7 +109,8 @@ void c_main(void)
   // Prepare filtering
   input_filtering_initialise_output(&filters, params.input_size);
   input_filtering_get_filters(&filters, region_start(2, address), NULL);
-  input_filtering_get_routes(&filters, &filter_routing, region_start(3, address));
+  input_filtering_get_routes(&filters, &filter_routing,
+                             (filter_routes_t *) region_start(3, address));
 
   // Retrieve the recording region
   rec_start = region_start(15, address);