synapse_row.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 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 _SYNAPSE_ROW_H_
#define _SYNAPSE_ROW_H_
 
#include <common/neuron-typedefs.h>
 
#ifndef SYNAPSE_WEIGHT_BITS
#define SYNAPSE_WEIGHT_BITS 16
#endif
 
#ifdef SYNAPSE_WEIGHTS_SIGNED
typedef __int_t(SYNAPSE_WEIGHT_BITS) weight_t;
#else
typedef __uint_t(SYNAPSE_WEIGHT_BITS) weight_t;
#endif
typedef uint16_t control_t;
 
#define N_SYNAPSE_ROW_HEADER_WORDS 3
 
typedef struct {
    size_t size;                
    uint32_t data[];            
} synapse_row_plastic_part_t;
 
typedef struct {
    size_t num_fixed;           
    size_t num_plastic;         
    uint32_t data[];            
} synapse_row_fixed_part_t;
 
typedef struct synapse_row_plastic_data_t synapse_row_plastic_data_t;
 
static inline size_t synapse_row_plastic_size(const synaptic_row_t row) {
    const synapse_row_plastic_part_t *the_row =
            (const synapse_row_plastic_part_t *) row;
    return the_row->size;
}
 
static inline synapse_row_plastic_data_t *synapse_row_plastic_region(
        synaptic_row_t row) {
    synapse_row_plastic_part_t *the_row = (synapse_row_plastic_part_t *) row;
    return (synapse_row_plastic_data_t *) the_row->data;
}
 
static inline synapse_row_fixed_part_t *synapse_row_fixed_region(
        synaptic_row_t row) {
    synapse_row_plastic_part_t *the_row = (synapse_row_plastic_part_t *) row;
    return (synapse_row_fixed_part_t *) &the_row->data[the_row->size];
}
 
static inline size_t synapse_row_num_fixed_synapses(
        const synapse_row_fixed_part_t *fixed) {
    return fixed->num_fixed;
}
 
static inline size_t synapse_row_num_plastic_controls(
        const synapse_row_fixed_part_t *fixed) {
    return fixed->num_plastic;
}
 
static inline control_t *synapse_row_plastic_controls(
        synapse_row_fixed_part_t *fixed) {
    return (control_t *) &fixed->data[fixed->num_fixed];
}
 
static inline uint32_t *synapse_row_fixed_weight_controls(
        synapse_row_fixed_part_t *fixed) {
    return fixed->data;
}
 
// The following are offset calculations into the ring buffers
static inline index_t synapse_row_sparse_index(
        uint32_t x, uint32_t synapse_index_mask) {
    return x & synapse_index_mask;
}
 
static inline index_t synapse_row_sparse_type(
        uint32_t x, uint32_t synapse_index_bits, uint32_t synapse_type_mask) {
    return (x >> synapse_index_bits) & synapse_type_mask;
}
 
static inline index_t synapse_row_sparse_type_index(
        uint32_t x, uint32_t synapse_type_index_mask) {
    return x & synapse_type_index_mask;
}
 
static inline index_t synapse_row_sparse_delay(
        uint32_t x, uint32_t synapse_type_index_bits, uint32_t synapse_delay_mask) {
    return (x >> synapse_type_index_bits) & synapse_delay_mask;
}
 
static inline weight_t synapse_row_sparse_weight(uint32_t x) {
    return x >> (32 - SYNAPSE_WEIGHT_BITS);
}
 
static inline input_t synapse_row_convert_weight_to_input(
        weight_t weight, uint32_t left_shift) {
    union {
        int_k_t input_type;
        s1615 output_type;
    } converter;
 
    converter.input_type = (int_k_t) (weight) << left_shift;
 
    return converter.output_type;
}
 
static inline index_t synapse_row_get_ring_buffer_index(
        uint32_t simulation_timestep, uint32_t synapse_type_index,
        uint32_t neuron_index, uint32_t synapse_type_index_bits,
        uint32_t synapse_index_bits, uint32_t synapse_delay_mask) {
    return ((simulation_timestep & synapse_delay_mask) << synapse_type_index_bits)
            | (synapse_type_index << synapse_index_bits)
            | neuron_index;
}
 
static inline index_t synapse_row_get_ring_buffer_index_time_0(
        uint32_t synapse_type_index, uint32_t neuron_index,
        uint32_t synapse_index_bits) {
    return (synapse_type_index << synapse_index_bits) | neuron_index;
}
 
static inline index_t synapse_row_get_first_ring_buffer_index(
        uint32_t simulation_timestep, uint32_t synapse_type_index_bits,
        int32_t synapse_delay_mask) {
    return (simulation_timestep & synapse_delay_mask) << synapse_type_index_bits;
}
 
static inline index_t synapse_row_get_ring_buffer_index_combined(
        uint32_t simulation_timestep,
        uint32_t combined_synapse_neuron_index,
        uint32_t synapse_type_index_bits, uint32_t synapse_delay_mask) {
    return ((simulation_timestep & synapse_delay_mask) << synapse_type_index_bits)
            | combined_synapse_neuron_index;
}
 
#endif  // SYNAPSE_ROW_H