//----------------------------------------------------------------------------- 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; }