matrix_generator_stdp.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.
 */
 
#include <stdbool.h>
#include <spin1_api.h>
#include <debug.h>
#include <delay_extension/delay_extension.h>
#include "matrix_generator_common.h"
#include <synapse_expander/generator_types.h>
#include <utils.h>
 
typedef struct {
    uint32_t plastic_plastic_size;   
    uint16_t plastic_plastic_data[]; 
} row_plastic_t;
 
typedef struct {
    uint32_t fixed_fixed_size;      
    uint32_t fixed_plastic_size;    
    uint16_t fixed_plastic_data[];  
} row_fixed_t;
 
typedef struct matrix_generator_stdp {
    union {
        uint32_t *synaptic_matrix;
        uint32_t synaptic_matrix_offset;
    };
    union {
        uint32_t *delayed_synaptic_matrix;
        uint32_t delayed_matrix_offset;
    };
    uint32_t max_row_n_synapses;
    uint32_t max_delayed_row_n_synapses;
    uint32_t max_row_n_words;
    uint32_t max_delayed_row_n_words;
    uint32_t synapse_type;
    uint32_t synapse_type_bits;
    uint32_t synapse_index_bits;
    uint32_t max_stage;
    uint32_t max_delay_per_stage;
    uint32_t delay_bits;
    uint32_t n_pre_neurons;
    uint32_t n_pre_neurons_per_core;
    uint32_t n_half_words_per_pp_row_header;
    uint32_t n_half_words_per_pp_synapse;
    uint32_t weight_half_word;
    uint32_t first_word_is_row_index;
    uint32_t row_offset;
} matrix_generator_stdp_data_t;
 
static uint32_t plastic_half_words(uint32_t n_half_words_per_pp_header,
        uint32_t n_half_words_per_pp_synapse, uint32_t max_row_n_synapses) {
    uint32_t n_half_words = n_half_words_per_pp_header
            + (n_half_words_per_pp_synapse * max_row_n_synapses);
    if (n_half_words & 0x1) {
        n_half_words += 1;
    }
    return n_half_words;
}
 
static row_fixed_t *get_stdp_fixed_row(row_plastic_t *plastic_row,
        uint32_t n_half_words_per_pp_header, uint32_t n_half_words_per_pp_synapse,
        uint32_t max_row_n_synapses) {
    uint32_t idx_16 = plastic_half_words(n_half_words_per_pp_header,
            n_half_words_per_pp_synapse, max_row_n_synapses);
    return (row_fixed_t *) &(plastic_row->plastic_plastic_data[idx_16]);
}
 
static void setup_stdp_rows(uint32_t *matrix, uint32_t n_rows,
        uint32_t n_half_words_per_pp_header, uint32_t n_half_words_per_pp_synapse,
        uint32_t max_row_n_synapses, uint32_t max_row_n_words,
        uint32_t first_header_word_is_row_index, uint32_t row_offset) {
 
    // Set all the header half-words to 0 and set all the sizes
    uint32_t plastic_words = plastic_half_words(n_half_words_per_pp_header,
            n_half_words_per_pp_synapse, max_row_n_synapses) >> 1;
    for (uint32_t i = 0; i < n_rows; i++) {
        row_plastic_t *row = get_row(matrix, max_row_n_words, i);
        // Use word writing for efficiency (and to write the first word)
        uint32_t *data = (uint32_t *) &row->plastic_plastic_data[0];
        if (first_header_word_is_row_index) {
            data[0] = i + row_offset;
        } else {
            data[0] = 0;
        }
        for (uint32_t j = 1; j < plastic_words; j++) {
            data[j] = 0;
        }
        row->plastic_plastic_size = plastic_words;
        row_fixed_t *fixed = get_stdp_fixed_row(row, n_half_words_per_pp_header,
                n_half_words_per_pp_synapse, max_row_n_synapses);
        fixed->fixed_fixed_size = 0;
        fixed->fixed_plastic_size = 0;
    }
}
 
 
static uint16_t build_fixed_plastic_half_word(
        uint16_t delay, uint32_t type,
        uint32_t post_index, uint32_t synapse_type_bits,
        uint32_t synapse_index_bits, uint32_t delay_bits) {
    uint16_t synapse_index_mask = (1 << synapse_index_bits) - 1;
    uint16_t synapse_type_mask = (1 << synapse_type_bits) - 1;
    uint16_t delay_mask = (1 << delay_bits) - 1;
 
    uint16_t wrd = post_index & synapse_index_mask;
    wrd |= (type & synapse_type_mask) << synapse_index_bits;
    wrd |= (delay & delay_mask) <<
            (synapse_index_bits + synapse_type_bits);
    // wrd |= (delay & SYNAPSE_DELAY_MASK) << synapse_type_bits;
 
    return wrd;
}
 
void *matrix_generator_stdp_initialize(void **region, void *synaptic_matrix) {
    // Allocate memory for the parameters
    matrix_generator_stdp_data_t *obj =
            spin1_malloc(sizeof(matrix_generator_stdp_data_t));
 
    // Copy the parameters in
    matrix_generator_stdp_data_t *params_sdram = *region;
    *obj = *params_sdram;
    *region = &params_sdram[1];
 
    // Offsets are in words
    uint32_t *syn_mat = synaptic_matrix;
    if (obj->synaptic_matrix_offset != 0xFFFFFFFF) {
        obj->synaptic_matrix = &(syn_mat[obj->synaptic_matrix_offset]);
        setup_stdp_rows(obj->synaptic_matrix, obj->n_pre_neurons,
                obj->n_half_words_per_pp_row_header,
                obj->n_half_words_per_pp_synapse, obj->max_row_n_synapses,
                obj->max_row_n_words, obj->first_word_is_row_index,
                obj->row_offset);
    } else {
        obj->synaptic_matrix = NULL;
    }
 
    if (obj->delayed_matrix_offset != 0xFFFFFFFF) {
        obj->delayed_synaptic_matrix = &(syn_mat[obj->delayed_matrix_offset]);
        setup_stdp_rows(obj->delayed_synaptic_matrix,
                obj->n_pre_neurons * (obj->max_stage - 1),
                obj->n_half_words_per_pp_row_header,
                obj->n_half_words_per_pp_synapse,
                obj->max_delayed_row_n_synapses, obj->max_delayed_row_n_words,
                obj->first_word_is_row_index, obj->row_offset);
    } else {
        obj->delayed_synaptic_matrix = NULL;
    }
 
    return obj;
}
 
void matrix_generator_stdp_free(void *generator) {
    sark_free(generator);
}
 
static bool matrix_generator_stdp_write_synapse(void *generator,
        uint32_t pre_index, uint16_t post_index, accum weight, uint16_t delay,
        unsigned long accum weight_scale) {
    matrix_generator_stdp_data_t *data = generator;
    struct delay_value delay_and_stage = get_delay(delay, data->max_stage,
            data->max_delay_per_stage);
    row_plastic_t *plastic_row;
    row_fixed_t *fixed_row;
    uint32_t pos;
    if (delay_and_stage.stage == 0) {
        plastic_row = get_row(data->synaptic_matrix, data->max_row_n_words,
                pre_index);
        fixed_row = get_stdp_fixed_row(plastic_row,
                data->n_half_words_per_pp_row_header,
                data->n_half_words_per_pp_synapse, data->max_row_n_synapses);
        pos = fixed_row->fixed_plastic_size;
        if (pos >= data->max_row_n_synapses) {
            log_warning("Row %u at 0x%08x, 0x%08x of matrix 0x%08x is already full (%u of %u)",
                pre_index, plastic_row, fixed_row, data->synaptic_matrix, pos,
                data->max_row_n_synapses);
            return false;
        }
    } else {
        plastic_row = get_delay_row(data->delayed_synaptic_matrix,
                data->max_delayed_row_n_words, pre_index, delay_and_stage.stage,
                data->n_pre_neurons_per_core, data->max_stage, data->n_pre_neurons);
        fixed_row = get_stdp_fixed_row(plastic_row,
                data->n_half_words_per_pp_row_header,
                data->n_half_words_per_pp_synapse, data->max_delayed_row_n_synapses);
        pos = fixed_row->fixed_plastic_size;
        if (pos >= data->max_delayed_row_n_synapses) {
            log_warning("Row %u at 0x%08x, 0x%08x of matrix 0x%08x is already full (%u of %u)",
                pre_index, plastic_row, fixed_row, data->synaptic_matrix, pos,
                data->max_delayed_row_n_synapses);
            return false;
        }
    }
 
    uint16_t scaled_weight = rescale_weight(weight, weight_scale);
 
    fixed_row->fixed_plastic_size = pos + 1;
    fixed_row->fixed_plastic_data[pos] = build_fixed_plastic_half_word(
            delay_and_stage.delay, data->synapse_type, post_index,
            data->synapse_type_bits, data->synapse_index_bits, data->delay_bits);
    uint32_t plastic_pos = data->n_half_words_per_pp_row_header
            + (data->n_half_words_per_pp_synapse * pos) + data->weight_half_word;
    plastic_row->plastic_plastic_data[plastic_pos] = scaled_weight;
    return true;
}