c_main_synapses.c

Go to the documentation of this file.

/*
 * Copyright (c) 2017 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "c_main_synapse_common.h"
#include "c_main_common.h"
#include "spike_processing_fast.h"
#include "structural_plasticity/synaptogenesis_dynamics.h"
#include <spin1_api_params.h>
 
typedef enum callback_priorities {
    MC = -1, DMA = -2, TIMER = 0, SDP = 0
} callback_priorities;
 
struct provenance_data {
    struct synapse_provenance synapse_prov;
    struct spike_processing_fast_provenance spike_processing_prov;
};
 
enum regions {
    SYSTEM_REGION,
    PROVENANCE_DATA_REGION,
    PROFILER_REGION,
    RECORDING_REGION,
    SYNAPSE_PARAMS_REGION,
    SYNAPTIC_MATRIX_REGION,
    POPULATION_TABLE_REGION,
    SYNAPSE_DYNAMICS_REGION,
    STRUCTURAL_DYNAMICS_REGION,
    BIT_FIELD_FILTER_REGION,
    SDRAM_PARAMS_REGION,
    KEY_REGION
};
 
const struct common_regions COMMON_REGIONS = {
    .system = SYSTEM_REGION,
    .provenance = PROVENANCE_DATA_REGION,
    .profiler = PROFILER_REGION,
    .recording = RECORDING_REGION
};
 
const struct common_priorities COMMON_PRIORITIES = {
    .sdp = SDP,
    .dma = DMA,
    .timer = TIMER
};
 
const struct synapse_regions SYNAPSE_REGIONS = {
    .synapse_params = SYNAPSE_PARAMS_REGION,
    .synaptic_matrix = SYNAPTIC_MATRIX_REGION,
    .pop_table = POPULATION_TABLE_REGION,
    .synapse_dynamics = SYNAPSE_DYNAMICS_REGION,
    .structural_dynamics = STRUCTURAL_DYNAMICS_REGION,
    .bitfield_filter = BIT_FIELD_FILTER_REGION
};
 
// the timer tick callback returning the same value.
uint32_t time;
 
static uint32_t timer_period;
 
static uint32_t simulation_ticks = 0;
 
static uint32_t infinite_run;
 
static uint32_t recording_flags = 0;
 
static void store_provenance_data(address_t provenance_region) {
    struct provenance_data *prov = (void *) provenance_region;
    store_synapse_provenance(&prov->synapse_prov);
    spike_processing_fast_store_provenance(&prov->spike_processing_prov);
}
 
void resume_callback(void) {
 
    // Reset recording
    recording_reset();
 
    // Resume synapses
    // NOTE: at reset, time is set to UINT_MAX ahead of timer_callback(...)
    synapses_resume(time + 1);
}
 
void timer_callback(UNUSED uint unused0, UNUSED uint unused1) {
    time++;
    if (simulation_is_finished()) {
        // Enter pause and resume state to avoid another tick
        simulation_handle_pause_resume(resume_callback);
 
        // Pause common functions
        common_pause(recording_flags);
 
        simulation_ready_to_read();
        return;
    }
 
    uint32_t n_rewires = synaptogenesis_n_updates();
    spike_processing_fast_time_step_loop(time, n_rewires);
}
 
static bool initialise(void) {
    data_specification_metadata_t *ds_regions;
    if (!initialise_common_regions(
            &timer_period, &simulation_ticks, &infinite_run, &time,
            &recording_flags, store_provenance_data, timer_callback,
            COMMON_REGIONS, COMMON_PRIORITIES, &ds_regions)) {
        return false;
    }
 
    // Setup synapses
    uint32_t incoming_spike_buffer_size;
    uint32_t row_max_n_words;
    bool clear_input_buffer_of_late_packets;
    weight_t *ring_buffers;
    uint32_t n_rec_regions_used = 0;
    if (!initialise_synapse_regions(
            ds_regions, SYNAPSE_REGIONS, &ring_buffers, &row_max_n_words,
            &incoming_spike_buffer_size,
            &clear_input_buffer_of_late_packets, &n_rec_regions_used)) {
        return false;
    }
 
    // Setup for writing synaptic inputs at the end of each run
    struct sdram_config *sdram_config = data_specification_get_region(
            SDRAM_PARAMS_REGION, ds_regions);
    struct key_config *key_config = data_specification_get_region(
            KEY_REGION, ds_regions);
 
    if (!spike_processing_fast_initialise(
            row_max_n_words, incoming_spike_buffer_size,
            clear_input_buffer_of_late_packets, n_rec_regions_used, MC,
            *sdram_config, *key_config, ring_buffers)) {
        return false;
    }
 
    // Do bitfield configuration last to only use any unused memory
    if (!population_table_load_bitfields(data_specification_get_region(
            SYNAPSE_REGIONS.bitfield_filter, ds_regions))) {
        return false;
    }
 
    // Set timer tick (in microseconds)
    log_debug("setting timer tick callback for %d microseconds", timer_period);
    spin1_set_timer_tick(timer_period);
 
    recording_reset();
 
    return true;
}
 
void c_main(void) {
 
    // initialise the model
    if (!initialise()) {
        rt_error(RTE_API);
    }
 
    simulation_run();
}