c_main_neurons.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_neuron_common.h"
#include "c_main_common.h"
#include "profile_tags.h"
#include "dma_common.h"
#include <spin1_api_params.h>
 
typedef enum callback_priorities {
    DMA = -2, SDP = 0, TIMER = 0
} callback_priorities;
 
enum regions {
    SYSTEM_REGION,
    CORE_PARAMS_REGION,
    PROVENANCE_DATA_REGION,
    PROFILER_REGION,
    RECORDING_REGION,
    NEURON_PARAMS_REGION,
    CURRENT_SOURCE_PARAMS_REGION,
    NEURON_RECORDING_REGION,
    SDRAM_PARAMS_REGION,
    INITIAL_VALUES_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 neuron_regions NEURON_REGIONS = {
    .core_params = CORE_PARAMS_REGION,
    .neuron_params = NEURON_PARAMS_REGION,
    .current_source_params = CURRENT_SOURCE_PARAMS_REGION,
    .neuron_recording = NEURON_RECORDING_REGION,
    .initial_values = INITIAL_VALUES_REGION
};
 
struct sdram_config {
    uint8_t *address;
    uint32_t size_in_bytes;
    uint32_t n_synapse_cores;
};
 
struct neurons_provenance {
    uint32_t n_timer_overruns;
};
 
#define N_SYNAPTIC_BUFFERS 2
 
// 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 struct sdram_config sdram_inputs;
 
static weight_t *synaptic_contributions[N_SYNAPTIC_BUFFERS];
 
static uint32_t timer_overruns = 0;
 
static union {
    uint32_t *as_int;
    weight_t *as_weight;
} all_synaptic_contributions;
 
 
static void store_provenance_data(address_t provenance_region) {
    struct neuron_provenance *prov = (void *) provenance_region;
    store_neuron_provenance(prov);
    struct neurons_provenance *n_prov = (void *) &prov[1];
    n_prov->n_timer_overruns = timer_overruns;
 
}
 
void resume_callback(void) {
 
    // Reset recording
    recording_reset();
 
    // try resuming neuron
    // NOTE: at reset, time is set to UINT_MAX ahead of timer_callback(...)
    if (!neuron_resume(time + 1)) {
        log_error("failed to resume neuron.");
        rt_error(RTE_SWERR);
    }
}
 
static inline void sum(weight_t *syns) {
    uint32_t n_words = sdram_inputs.size_in_bytes >> 2;
    const uint32_t *src = (const uint32_t *) syns;
    uint32_t *tgt = all_synaptic_contributions.as_int;
    for (uint32_t i = n_words; i > 0; i--) {
        *tgt++ += *src++;
    }
}
 
void timer_callback(uint timer_count, UNUSED uint unused) {
 
    profiler_write_entry_disable_irq_fiq(PROFILER_ENTER | PROFILER_TIMER);
 
    uint32_t start_time = tc[T1_COUNT];
 
    time++;
 
    log_debug("Timer tick %u \n", time);
 
    /* if a fixed number of simulation ticks that were specified at startup
     * then do reporting for finishing */
    if (simulation_is_finished()) {
 
        // Enter pause and resume state to avoid another tick
        simulation_handle_pause_resume(resume_callback);
 
        // Pause neuron processing
        neuron_pause();
 
        // Pause common functions
        common_pause(recording_flags);
 
        profiler_write_entry_disable_irq_fiq(PROFILER_EXIT | PROFILER_TIMER);
 
        // Subtract 1 from the time so this tick gets done again on the next
        // run
        time--;
 
        simulation_ready_to_read();
        return;
    }
 
    // Start the transfer of the first part of the weight data
    uint8_t *sdram = sdram_inputs.address;
    uint32_t write_index = 0;
    uint32_t read_index = 0;
 
    // Start the first DMA
    do_fast_dma_read(sdram, synaptic_contributions[write_index],
            sdram_inputs.size_in_bytes);
    write_index = !write_index;
 
    for (uint32_t i = 0; i < sdram_inputs.n_synapse_cores; i++) {
        // Wait for the last DMA to complete
        wait_for_dma_to_complete();
 
        // Start the next DMA if not finished
        if (i + 1 < sdram_inputs.n_synapse_cores) {
            sdram += sdram_inputs.size_in_bytes;
            do_fast_dma_read(sdram, synaptic_contributions[write_index],
                    sdram_inputs.size_in_bytes);
            write_index = !write_index;
        }
 
        // Add in the contributions from the last read item
        sum(synaptic_contributions[read_index]);
        read_index = !read_index;
    }
 
    neuron_transfer(all_synaptic_contributions.as_weight);
 
    // Now do neuron time step update
    neuron_do_timestep_update(time, timer_count);
 
    uint32_t end_time = tc[T1_COUNT];
    if (end_time > start_time) {
        timer_overruns += 1;
    }
 
    profiler_write_entry_disable_irq_fiq(PROFILER_EXIT | PROFILER_TIMER);
}
 
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 neurons
    uint32_t n_rec_regions_used;
    if (!initialise_neuron_regions(
            ds_regions, NEURON_REGIONS,  &n_rec_regions_used)) {
        return false;
    }
 
    // Setup for reading synaptic inputs at start of each time step
    struct sdram_config * sdram_config = data_specification_get_region(
            SDRAM_PARAMS_REGION, ds_regions);
    spin1_memcpy(&sdram_inputs, sdram_config, sizeof(struct sdram_config));
 
    uint32_t n_words = sdram_inputs.size_in_bytes >> 2;
    uint32_t n_weights = sdram_inputs.size_in_bytes >> 1;
    for (uint32_t i = 0; i < N_SYNAPTIC_BUFFERS; i++) {
        synaptic_contributions[i] = spin1_malloc(sdram_inputs.size_in_bytes);
        if (synaptic_contributions[i] == NULL) {
            log_error("Could not allocate %d bytes for synaptic contributions %d",
                    sdram_inputs.size_in_bytes, i);
            return false;
        }
        for (uint32_t j = 0; j < n_weights; j++) {
            synaptic_contributions[i][j] = 0;
        }
    }
    all_synaptic_contributions.as_int = spin1_malloc(sdram_inputs.size_in_bytes);
    if (all_synaptic_contributions.as_int == NULL) {
        log_error("Could not allocate %d bytes for all synaptic contributions",
                sdram_inputs.size_in_bytes);
        return false;
    }
    for (uint32_t j = 0; j < n_words; j++) {
        all_synaptic_contributions.as_int[j] = 0;
    }
    uint32_t *sdram_word = (void *) sdram_inputs.address;
    for (uint32_t i = 0; i < sdram_inputs.n_synapse_cores; i++) {
        for (uint32_t j = 0; j < n_words; j++) {
            *(sdram_word++) = 0;
        }
    }
    // Set timer tick (in microseconds)
    log_debug("setting timer tick callback for %d microseconds", timer_period);
    spin1_set_timer_tick(timer_period);
 
    return true;
}
 
void c_main(void) {
 
    // Start the time at "-1" so that the first tick will be 0
    time = UINT32_MAX;
 
    // initialise the model
    if (!initialise()) {
        rt_error(RTE_API);
    }
 
    simulation_run();
}