//-----------------------------------------------------------------------------
bool pes_initialise(address_t address)
{
// Read number of PES learning rules that are configured
g_num_pes_learning_rules = address[0];
io_printf(IO_BUF, "PES learning: Num rules:%u\n", g_num_pes_learning_rules);
if(g_num_pes_learning_rules > 0)
{
// Allocate memory
MALLOC_FAIL_FALSE(g_pes_learning_rules,
g_num_pes_learning_rules * sizeof(pes_parameters_t));
// Copy learning rules from region into new array
memcpy(g_pes_learning_rules, &address[1], g_num_pes_learning_rules * sizeof(pes_parameters_t));
// Display debug
for(uint32_t l = 0; l < g_num_pes_learning_rules; l++)
{
const pes_parameters_t *parameters = &g_pes_learning_rules[l];
io_printf(IO_BUF, "\tRule %u, Learning rate:%k, Error signal index:%u, "
"Error signal start dimension:%u, Error signal end dimensions:%u,"
"Decoder row:%u, Activity filter index:%d\n",
l, parameters->learning_rate, parameters->error_sig_index,
parameters->error_start_dim, parameters->error_end_dim,
parameters->decoder_row, parameters->activity_filter_index);
}
}
return true;
}
bool data_get_output_keys(address_t addr) {
MALLOC_FAIL_FALSE(g_filter.keys,
g_filter.size_out * sizeof(uint));
spin1_memcpy(
g_filter.keys, addr, g_filter.size_out * sizeof(uint));
for (uint i = 0; i < g_filter.size_out; i++)
io_printf(IO_BUF, "g_filter.keys[%d] = %08x\n", i, g_filter.keys[i]);
return true;
}
bool data_get_transform(address_t addr) {
MALLOC_FAIL_FALSE(g_filter.transform,
sizeof(value_t) * g_filter.size_in * g_filter.size_out);
spin1_memcpy(g_filter.transform, addr,
g_filter.size_in * g_filter.size_out * sizeof(uint));
io_printf(IO_BUF, "Transform = [");
for (uint i = 0; i < g_filter.size_out; i++) {
for (uint j = 0; j < g_filter.size_in; j++) {
io_printf(IO_BUF, "%k ", g_filter.transform[i*g_filter.size_in + j]);
}
io_printf(IO_BUF, "\n");
}
io_printf(IO_BUF, "]\n");
return true;
}
bool data_system(address_t addr) {
g_filter.size_in = addr[0];
g_filter.size_out = addr[1];
g_filter.machine_timestep = addr[2];
g_filter.transmission_delay = addr[3];
g_filter.interpacket_pause = addr[4];
delay_remaining = g_filter.transmission_delay;
io_printf(IO_BUF, "[Filter] transmission delay = %d\n", delay_remaining);
g_filter.input = input_filter_initialise(&g_input, g_filter.size_in);
if (g_filter.input == NULL)
return false;
MALLOC_FAIL_FALSE(g_filter.output, g_filter.size_out * sizeof(value_t));
return true;
}
bool get_packets(address_t source, uint** dest) {
// Allocate some space for the packets list
uint* dest_;
MALLOC_FAIL_FALSE(dest_, source[0] * sizeof(mc_packet_t) + 1);
dest[0] = dest_;
// Copy those packets across
spin1_memcpy(dest_, source, sizeof(uint) + sizeof(mc_packet_t) * source[0]);
// Print all packets
io_printf(IO_BUF, "%d packets:\n", source[0]);
mc_packet_t *packets = (mc_packet_t *) (&source[1]);
for (uint i = 0; i < source[0]; i++) {
io_printf(IO_BUF, "\tTime %d, Key 0x%08x, Payload 0x%08x\n",
packets[i].timestamp, packets[i].key, packets[i].payload);
}
return true;
}
bool input_filter_bank_initialise(input_filter_bank_t *bank,
address_t widths,
bool allocate_accumulator) {
// Malloc sufficient space for the filters, then initialise each
bank->n_inputs = widths[0];
MALLOC_FAIL_FALSE(bank->inputs, bank->n_inputs * sizeof(input_filter_t));
for (uint d = 0; d < bank->n_inputs; d++)
{
value_t *accumulator = input_filter_initialise(bank->inputs[d],
widths[d], allocate_accumulator);
// If we required one and the accululator
// Cannot be initialised then return false
if (allocate_accumulator && accumulator == NULL)
{
return false;
}
}
return true;
}
