sp_structs.h

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.
 */
 
#ifndef _SP_STRUCTS_H_
#define _SP_STRUCTS_H_
 
#include <neuron/plasticity/synapse_dynamics.h>
#include <neuron/synapse_row.h>
#include <debug.h>
#include <random.h>
 
// Define the formation and elimination params
struct elimination_params;
struct formation_params;
 
#define IS_CONNECTION_LAT 1
 
#ifndef SOMETIMES_UNUSED
#define SOMETIMES_UNUSED __attribute__((unused))
#endif // !SOMETIMES_UNUSED
 
typedef struct post_to_pre_entry {
    uint8_t pop_index;
    uint8_t sub_pop_index;
    uint16_t neuron_index;
} post_to_pre_entry;
 
typedef struct {
    uint32_t key;
    uint32_t mask;
    uint32_t n_colour_bits;
    uint32_t n_atoms;
    uint32_t lo_atom;
    uint32_t m_pop_index;
} key_atom_info_t;
 
typedef struct {
    uint16_t no_pre_vertices;
    uint16_t sp_control;
    uint16_t delay_lo;
    uint16_t delay_hi;
    uint32_t weight;
    uint32_t connection_type;
    uint32_t total_no_atoms;
    key_atom_info_t key_atom_info[];
} pre_info_t;
 
typedef struct {
    uint32_t no_pre_pops;
    pre_info_t **prepop_info;
} pre_pop_info_table_t;
 
typedef struct {
    uint32_t fast;
    uint32_t p_rew;
    uint32_t s_max;
    uint32_t app_no_atoms;
    uint32_t machine_no_atoms;
    uint32_t low_atom;
    uint32_t high_atom;
    uint32_t with_replacement;
    // the 2 seeds that are used: shared for sync, local for everything else
    mars_kiss64_seed_t shared_seed;
    mars_kiss64_seed_t local_seed;
    uint32_t no_pre_pops;
} rewiring_data_t;
 
typedef struct {
    mars_kiss64_seed_t *local_seed;
    uint32_t post_low_atom;
    // with_replacement copied from rewiring data
    uint32_t with_replacement;
    // what are the currently selecting pre- and post-synaptic neurons
    uint32_t pre_syn_id;
    uint32_t post_syn_id;
    uint32_t element_exists;
    // information extracted from the post to pre table
    post_to_pre_entry *post_to_pre_table_entry;
    pre_info_t *pre_population_info;
    key_atom_info_t *key_atom_info;
    post_to_pre_entry post_to_pre;
    uint32_t offset;
    uint16_t delay;
    uint16_t weight;
    uint32_t synapse_type;
} current_state_t;
 
static inline uint32_t rand_int(uint32_t max, mars_kiss64_seed_t seed) {
    return muliulr(max, ulrbits(mars_kiss64_seed(seed)));
}
 
static inline bool sp_structs_find_by_spike(
        const pre_pop_info_table_t *pre_pop_info_table, spike_t spike,
        uint32_t *restrict neuron_id, uint32_t *restrict population_id,
        uint32_t *restrict sub_population_id, uint32_t *restrict m_pop_index) {
    // Amazing linear search inc.
    // Loop over all populations
    for (uint32_t i = 0; i < pre_pop_info_table->no_pre_pops; i++) {
        const pre_info_t *pre_pop_info = pre_pop_info_table->prepop_info[i];
 
        // Loop over all sub-populations and check if the KEY matches
        // (with neuron ID masked out)
        for (int j = 0; j < pre_pop_info->no_pre_vertices; j++) {
            const key_atom_info_t *kai = &pre_pop_info->key_atom_info[j];
            if ((spike & kai->mask) == kai->key) {
                *population_id = i;
                *sub_population_id = j;
                *neuron_id = (spike & ~kai->mask) >> kai->n_colour_bits;
                *m_pop_index = kai->m_pop_index;
                return true;
            }
        }
    }
    return false;
}
 
static inline bool sp_structs_get_sub_pop_info(
        const pre_pop_info_table_t *pre_pop_info_table, uint32_t population_id,
        uint32_t pop_neuron_id, uint32_t *restrict sub_population_id,
        uint32_t *restrict sub_pop_neuron_id, uint32_t *restrict spike) {
    const pre_info_t *app_pop_info =
            pre_pop_info_table->prepop_info[population_id];
    uint32_t neuron_id = pop_neuron_id;
    for (uint32_t i = 0; i < app_pop_info->no_pre_vertices; i++) {
        const key_atom_info_t *kai = &app_pop_info->key_atom_info[i];
        uint32_t n_atoms = kai->n_atoms;
        if (neuron_id < n_atoms) {
            *sub_population_id = i;
            *sub_pop_neuron_id = neuron_id;
            *spike = kai->key | (neuron_id << kai->n_colour_bits);
            return true;
        }
        neuron_id -= n_atoms;
    }
    return false;
}
 
static inline bool sp_structs_remove_synapse(
        current_state_t *restrict current_state, synaptic_row_t restrict row) {
    if (!synapse_dynamics_remove_neuron(current_state->offset, row)) {
        return false;
    }
 
    current_state->post_to_pre_table_entry->neuron_index = 0xFFFF;
    return true;
}
 
static inline bool sp_structs_add_synapse(
        current_state_t *restrict current_state, synaptic_row_t restrict row) {
    uint32_t appr_scaled_weight = current_state->pre_population_info->weight;
 
    uint32_t actual_delay;
    uint32_t offset = current_state->pre_population_info->delay_hi -
            current_state->pre_population_info->delay_lo;
    actual_delay = rand_int(offset, *(current_state->local_seed)) +
            current_state->pre_population_info->delay_lo;
 
    if (!synapse_dynamics_add_neuron(
            current_state->post_syn_id, row, appr_scaled_weight, actual_delay,
            current_state->pre_population_info->connection_type)) {
        return false;
    }
 
    // Critical: tell the compiler that this pointer is aligned so it doesn't
    // internally convert the assignment to a memcpy(), which is a saving of
    // hundreds of bytes...
    post_to_pre_entry *ppentry = __builtin_assume_aligned(
            current_state->post_to_pre_table_entry, 4);
    *ppentry = current_state->post_to_pre;
    return true;
}
 
static inline uint8_t *sp_structs_read_in_common(
        address_t sdram_sp_address, rewiring_data_t *rewiring_data,
        pre_pop_info_table_t *pre_info, post_to_pre_entry **post_to_pre_table) {
    uint8_t *data = (uint8_t *) sdram_sp_address;
    spin1_memcpy(rewiring_data, data, sizeof(rewiring_data_t));
    data += sizeof(rewiring_data_t);
 
    pre_info->no_pre_pops = rewiring_data->no_pre_pops;
    pre_info->prepop_info = spin1_malloc(
            rewiring_data->no_pre_pops * sizeof(pre_info_t *));
    if (pre_info->prepop_info == NULL) {
        log_error("Could not initialise pre population info");
        rt_error(RTE_SWERR);
    }
    for (uint32_t i = 0; i < rewiring_data->no_pre_pops; i++) {
        pre_info->prepop_info[i] = (pre_info_t *) data;
        uint32_t pre_size = (pre_info->prepop_info[i]->no_pre_vertices
                * sizeof(key_atom_info_t)) + sizeof(pre_info_t);
        pre_info->prepop_info[i] = spin1_malloc(pre_size);
        if (pre_info->prepop_info[i] == NULL) {
            log_error("Could not initialise pre population info %d", i);
            rt_error(RTE_SWERR);
        }
        spin1_memcpy(pre_info->prepop_info[i], data, pre_size);
 
        log_debug("no_pre = %u, sp_control %u, "
                "delay lo %u, delay hi %u, weight %d",
                pre_info->prepop_info[i]->no_pre_vertices,
                pre_info->prepop_info[i]->sp_control,
                pre_info->prepop_info[i]->delay_lo,
                pre_info->prepop_info[i]->delay_hi,
                pre_info->prepop_info[i]->weight);
        log_debug("connection_type = %d, total_no_atoms=%d",
                pre_info->prepop_info[i]->connection_type,
                pre_info->prepop_info[i]->total_no_atoms);
        data += pre_size;
    }
 
    *post_to_pre_table = (post_to_pre_entry *) data;
    uint32_t n_elements =
            rewiring_data->s_max * rewiring_data->machine_no_atoms;
 
    for (uint32_t i=0; i < n_elements; i++){
        log_debug("index %d, pop index %d, sub pop index %d, neuron_index %d",
                i, (*post_to_pre_table)[i].pop_index,
                (*post_to_pre_table)[i].sub_pop_index,
                (*post_to_pre_table)[i].neuron_index);
    }
    data += n_elements * sizeof(post_to_pre_entry);
    return (uint8_t *) data;
}
 
#endif // _SP_STRUCTS_H_