Spinncer weight scale

neural_modelling/makefiles/neuron/IF_cond_alpha/Makefile

@@ -0,0 +1,25 @@
+# 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.
+
+APP = $(notdir $(CURDIR))
+
+NEURON_MODEL = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.c
+NEURON_MODEL_H = $(NEURON_DIR)/neuron/models/neuron_model_lif_impl.h
+INPUT_TYPE_H = $(NEURON_DIR)/neuron/input_types/input_type_conductance.h
+NEURON_IMPL_H = $(NEURON_DIR)/neuron/implementations/neuron_impl_standard.h
+THRESHOLD_TYPE_H = $(NEURON_DIR)/neuron/threshold_types/threshold_type_static.h
+SYNAPSE_TYPE_H = $(NEURON_DIR)/neuron/synapse_types/synapse_types_alpha_impl.h
+SYNAPSE_DYNAMICS = $(NEURON_DIR)/neuron/plasticity/synapse_dynamics_static_impl.c
+
+include ../neural_build.mk

neural_modelling/src/common/send_mc.h

@@ -32,10 +32,10 @@ static inline void wait_for_cc(void) {
         spin1_delay_us(1);
         n_loops++;
     }
-    if (!(cc[CC_TCR] & TX_NOT_FULL_MASK)) {
-        log_error("Couldn't send spike; TCR=0x%08x\n", cc[CC_TCR]);
-        rt_error(RTE_SWERR);
-    }
+//    if (!(cc[CC_TCR] & TX_NOT_FULL_MASK)) {
+//        log_error("Couldn't send spike; TCR=0x%08x\n", cc[CC_TCR]);
+//        rt_error(RTE_SWERR);
+//    }
 }
 
 //! \brief Perform direct spike sending with hardware for speed

neural_modelling/src/delay_extension/delay_extension.h

@@ -24,6 +24,9 @@
 
 #include <common-typedefs.h>
 
+//! Constants
+#define DELAY_STAGE_LENGTH  64
+
 //! region identifiers
 typedef enum region_identifiers {
     //! General simulation system control

neural_modelling/src/neuron/additional_inputs/additional_input_ca2_adaptive_impl.h

@@ -76,7 +76,7 @@ static inline input_t additional_input_get_input_value_as_current(
     additional_input->i_ca2 *= additional_input->exp_tau_ca2;
 
     // Return the Ca2
-    return -additional_input->i_ca2;
+    return additional_input->i_ca2;
 }
 
 //! \brief Notifies the additional input type that the neuron has spiked

neural_modelling/src/neuron/c_main.c

@@ -37,8 +37,14 @@
 #include "c_main_common.h"
 #include "regions.h"
 #include "profile_tags.h"
+//#include "spike_profiling.h"
 #include "spike_processing.h"
 
+//struct spike_holder_t spike_counter;
+//struct spike_holder_t spike_cache;
+//struct spike_holder_t spike_counter_inh;
+//struct spike_holder_t spike_cache_inh;
+
 //! The combined provenance from synapses and neurons
 struct combined_provenance {
     struct neuron_provenance neuron_provenance;
@@ -70,6 +76,7 @@ const struct common_priorities COMMON_PRIORITIES = {
     .timer = TIMER
 };
 
+
 //! From the regions, extract those that are neuron-specific
 const struct neuron_regions NEURON_REGIONS = {
     .core_params = CORE_PARAMS_REGION,
@@ -153,9 +160,9 @@ static inline void process_ring_buffers(void) {
     neuron_transfer(&ring_buffers[first_index]);
 
     // Print the neuron inputs.
-    #if LOG_LEVEL >= LOG_DEBUG
-        neuron_print_inputs();
-    #endif // LOG_LEVEL >= LOG_DEBUG
+#if LOG_LEVEL >= LOG_DEBUG
+	neuron_print_inputs();
+#endif // LOG_LEVEL >= LOG_DEBUG
 }
 
 //! \brief Background activities called from timer
@@ -179,6 +186,18 @@ void background_callback(uint timer_count, uint local_time) {
 //!            executed since start of simulation
 //! \param[in] unused: unused parameter kept for API consistency
 void timer_callback(uint timer_count, UNUSED uint unused) {
+
+//    // Get number of spikes in last tick, and reset spike counter
+//    spike_processing_get_and_reset_spikes_this_tick();
+//    spike_processing_get_and_reset_dmas_this_tick();
+//    spike_processing_get_and_reset_pipeline_restarts_this_tick();
+//
+//    // cache and flush spike counters
+//	spike_profiling_cache_and_flush_spike_holder(&spike_counter,
+//			&spike_cache);
+//	spike_profiling_cache_and_flush_spike_holder(&spike_counter_inh,
+//			&spike_cache_inh);
+
     // Disable interrupts to stop DMAs and MC getting in the way of this bit
     uint32_t state = spin1_int_disable();
 

neural_modelling/src/neuron/c_main_synapse_common.h

@@ -105,13 +105,12 @@ static inline bool initialise_synapse_regions(
         bool *clear_input_buffer_of_late_packets,
         uint32_t *n_recording_regions_used) {
     // Set up the synapses
-    uint32_t *ring_buffer_to_input_buffer_left_shifts;
+    REAL *min_weights;
     uint32_t n_neurons;
     uint32_t n_synapse_types;
     if (!synapses_initialise(
             data_specification_get_region(regions.synapse_params, ds_regions),
-            &n_neurons, &n_synapse_types, ring_buffers,
-            &ring_buffer_to_input_buffer_left_shifts,
+            &n_neurons, &n_synapse_types, ring_buffers, &min_weights,
             clear_input_buffer_of_late_packets,
             incoming_spike_buffer_size)) {
         return false;
@@ -124,10 +123,11 @@ static inline bool initialise_synapse_regions(
             row_max_n_words)) {
         return false;
     }
+
     // Set up the synapse dynamics
     if (!synapse_dynamics_initialise(
             data_specification_get_region(regions.synapse_dynamics, ds_regions),
-            n_neurons, n_synapse_types, ring_buffer_to_input_buffer_left_shifts)) {
+            n_neurons, n_synapse_types, min_weights)) {
         return false;
     }
 
@@ -137,5 +137,6 @@ static inline bool initialise_synapse_regions(
         return false;
     }
 
+
     return true;
 }

neural_modelling/src/neuron/c_main_synapses.c

@@ -35,9 +35,20 @@
 #include "c_main_synapse_common.h"
 #include "c_main_common.h"
 #include "spike_processing_fast.h"
+#include "spike_profiling.h"
 #include "structural_plasticity/synaptogenesis_dynamics.h"
 #include <spin1_api_params.h>
 
+//! spike profiling
+struct spike_holder_t spike_counter;
+struct spike_holder_t spike_cache;
+struct spike_holder_t spike_counter_inh;
+struct spike_holder_t spike_cache_inh;
+
+//// FLUSH SPIKES ??
+//bool timer_callback_active = false;
+//extern volatile bool dma_busy;
+
 //! values for the priority for each callback
 typedef enum callback_priorities {
     MC = -1, DMA = -2, TIMER = 0, SDP = 0
@@ -129,6 +140,17 @@ void resume_callback(void) {
 //! \param[in] unused0: unused
 //! \param[in] unused1: unused
 void timer_callback(UNUSED uint unused0, UNUSED uint unused1) {
+    // Get number of spikes in last tick, and reset spike counter
+    spike_processing_get_and_reset_spikes_this_tick();
+    spike_processing_get_and_reset_dmas_this_tick();
+    spike_processing_get_and_reset_pipeline_restarts_this_tick();
+
+    // cache and flush spike counters
+    spike_profiling_cache_and_flush_spike_holder(&spike_counter,
+            &spike_cache);
+    spike_profiling_cache_and_flush_spike_holder(&spike_counter_inh,
+            &spike_cache_inh);
+
     time++;
     if (simulation_is_finished()) {
         // Enter pause and resume state to avoid another tick

neural_modelling/src/neuron/current_sources/current_source.h

@@ -58,7 +58,7 @@ SOMETIMES_UNUSED // Marked unused as only used sometimes
 static bool current_source_initialise(address_t cs_address, uint32_t n_neurons) {
     // Avoid the loops if no current sources
     #if !defined(_CURRENT_SOURCE_DC_H_) && !defined(_CURRENT_SOURCE_AC_H) && \
-		!defined(_CURRENT_SOURCE_STEP_H_) && !defined(_CURRENT_SOURCE_NOISY_H_)
+        !defined(_CURRENT_SOURCE_STEP_H_) && !defined(_CURRENT_SOURCE_NOISY_H_)
     return true;
     #else
 
@@ -150,7 +150,6 @@ static bool current_source_load_parameters(address_t cs_address) {
     // Avoid the loops if no current sources
     #if !defined(_CURRENT_SOURCE_DC_H_) && !defined(_CURRENT_SOURCE_AC_H) && \
         !defined(_CURRENT_SOURCE_STEP_H_) && !defined(_CURRENT_SOURCE_NOISY_H_)
-    io_printf(IO_BUF, "no current sources defined \n");
     return true;
     #else
 
@@ -207,7 +206,7 @@ SOMETIMES_UNUSED // Marked unused as only used sometimes
 static inline REAL current_source_get_offset(uint32_t time, uint32_t neuron_index) {
     // Avoid the loops if no current sources defined
     #if !defined(_CURRENT_SOURCE_DC_H_) && !defined(_CURRENT_SOURCE_AC_H) && \
-		!defined(_CURRENT_SOURCE_STEP_H_) && !defined(_CURRENT_SOURCE_NOISY_H_)
+        !defined(_CURRENT_SOURCE_STEP_H_) && !defined(_CURRENT_SOURCE_NOISY_H_)
     return ZERO;
     #else
 

neural_modelling/src/neuron/current_sources/current_source_ac.h

@@ -40,7 +40,7 @@ static bool current_source_ac_init(uint32_t n_ac_sources, uint32_t *next) {
 	for (uint32_t n_ac=0; n_ac < n_ac_sources; n_ac++) {
 		ac_source[n_ac] = spin1_malloc(sizeof(ac_source_t));
 		if (ac_source[n_ac] == NULL) {
-			log_error("Unable to allocate DC source parameters - out of DTCM");
+			log_error("Unable to allocate AC source parameters - out of DTCM");
 			return false;
 		}
 		*next += sizeof(ac_source_t) / 4;

neural_modelling/src/neuron/current_sources/current_source_noisy.h

@@ -41,7 +41,7 @@ static bool current_source_noisy_init(uint32_t n_noisy_sources, uint32_t *next)
 	for (uint32_t n_noisy=0; n_noisy < n_noisy_sources; n_noisy++) {
 		noisy_source[n_noisy] = spin1_malloc(sizeof(noisy_current_source_t));
 		if (noisy_source[n_noisy] == NULL) {
-			log_error("Unable to allocate DC source parameters - out of DTCM");
+			log_error("Unable to allocate noisy source parameters - out of DTCM");
 			return false;
 		}
 		*next += sizeof(noisy_current_source_t) / 4;

neural_modelling/src/neuron/current_sources/current_source_step.h

@@ -48,29 +48,20 @@ static bool current_source_step_init(
 		step_cs_amps = spin1_malloc(n_step_current_sources * sizeof(uint32_t*));
 		step_cs_amp_last = spin1_malloc(n_step_current_sources * sizeof(REAL));
 		step_cs_index = spin1_malloc(n_step_current_sources * sizeof(uint32_t));
-		if (step_cs_amp_last == NULL) {
-			log_error("Unable to allocate step current source amp last - out of DTCM");
-			return false;
-		}
-		if (step_cs_index == NULL) {
-			log_error("Unable to allocate step current source index - out of DTCM");
-			return false;
-		}
 	}
+
 	for (uint32_t n_step=0; n_step < n_step_current_sources; n_step++) {
 		uint32_t arr_len = (uint32_t) cs_address[*next];
 		uint32_t struct_size = (arr_len + 1) * sizeof(uint32_t);
 		step_cs_times[n_step] = spin1_malloc(struct_size);
 		if (step_cs_times[n_step] == NULL) {
-			log_error("Unable to allocate step current source times - out of DTCM",
-			        "struct_size is %u next %u n_step %u)", struct_size, *next, n_step);
+			log_error("Unable to allocate step current source times - out of DTCM");
 			return false;
 		}
 
 		step_cs_amps[n_step] = spin1_malloc(struct_size);
 		if (step_cs_amps[n_step] == NULL) {
-			log_error("Unable to allocate step current source amplitudes - out of DTCM",
-			        "(struct_size is %u next %u n_step %u)", struct_size, *next, n_step);
+			log_error("Unable to allocate step current source amplitudes - out of DTCM");
 			return false;
 		}
 

neural_modelling/src/neuron/implementations/neuron_impl_standard.h

@@ -164,7 +164,6 @@ SOMETIMES_UNUSED // Marked unused as only used sometimes
 static void neuron_impl_load_neuron_parameters(
         address_t address, uint32_t next, uint32_t n_neurons,
 		address_t save_initial_state) {
-
     // Read the number of steps per timestep
     n_steps_per_timestep = address[next++];
     if (n_steps_per_timestep == 0) {
@@ -252,6 +251,8 @@ static void neuron_impl_do_timestep_update(
         additional_input_t *additional_inputs = &additional_input_array[neuron_index];
         synapse_types_t *the_synapse_type = &synapse_types_array[neuron_index];
 
+//        bool spike = false;
+
         // Loop however many times requested; do this in reverse for efficiency,
         // and because the index doesn't actually matter
         for (uint32_t i_step = n_steps_per_timestep; i_step > 0; i_step--) {
@@ -265,26 +266,25 @@ static void neuron_impl_do_timestep_update(
             input_t inh_values[NUM_INHIBITORY_RECEPTORS];
             input_t *inh_syn_values =
                     synapse_types_get_inhibitory_input(inh_values, the_synapse_type);
-
             // Call functions to obtain exc_input and inh_input
             input_t *exc_input_values = input_type_get_input_value(
                     exc_syn_values, input_types, NUM_EXCITATORY_RECEPTORS);
             input_t *inh_input_values = input_type_get_input_value(
                     inh_syn_values, input_types, NUM_INHIBITORY_RECEPTORS);
 
-            // Sum g_syn contributions from all receptors for recording
-            REAL total_exc = ZERO;
-            REAL total_inh = ZERO;
-
-            for (int i = 0; i < NUM_EXCITATORY_RECEPTORS; i++) {
-                total_exc += exc_input_values[i];
-            }
-            for (int i = 0; i < NUM_INHIBITORY_RECEPTORS; i++) {
-                total_inh += inh_input_values[i];
-            }
-
             // Do recording if on the first step
             if (i_step == n_steps_per_timestep) {
+				// Sum g_syn contributions from all receptors for recording
+				REAL total_exc = ZERO;
+				REAL total_inh = ZERO;
+
+				for (int i = 0; i < NUM_EXCITATORY_RECEPTORS; i++) {
+					total_exc += exc_input_values[i];
+				}
+				for (int i = 0; i < NUM_INHIBITORY_RECEPTORS; i++) {
+					total_inh += inh_input_values[i];
+				}
+
                 neuron_recording_record_accum(
                         V_RECORDING_INDEX, neuron_index, soma_voltage);
                 neuron_recording_record_accum(
@@ -319,6 +319,8 @@ static void neuron_impl_do_timestep_update(
             // If spike occurs, communicate to relevant parts of model
             if (spike_now) {
 
+//                spike = true;
+
                 // Call relevant model-based functions
                 // Tell the neuron model
                 neuron_model_has_spiked(this_neuron);
@@ -340,6 +342,14 @@ static void neuron_impl_do_timestep_update(
     #if LOG_LEVEL >= LOG_DEBUG
         neuron_model_print_state_variables(this_neuron);
     #endif // LOG_LEVEL >= LOG_DEBUG
+
+//        if (spike) {
+//            // Record the spike
+//            neuron_recording_record_bit(SPIKE_RECORDING_BITFIELD, neuron_index);
+//
+//            // Send the spike
+//            send_spike(timer_count, time, neuron_index);
+//        }
     }
 }
 

neural_modelling/src/neuron/input_types/input_type_conductance.h

@@ -20,6 +20,7 @@
 #define _INPUT_TYPE_CONDUCTANCE_H_
 
 #include "input_type.h"
+#include "round.h"
 
 //! Conductance input parameters
 struct input_type_params_t {
@@ -59,7 +60,7 @@ static inline input_t *input_type_get_input_value(
         input_t *restrict value, UNUSED input_type_t *input_type,
         uint16_t num_receptors) {
     for (int i = 0; i < num_receptors; i++) {
-        value[i] = value[i] >> 10;
+        value[i] = value[i] >> 5;
     }
     return &value[0];
 }
@@ -74,7 +75,10 @@ static inline void input_type_convert_excitatory_input_to_current(
         input_t *restrict exc_input, const input_type_t *input_type,
         state_t membrane_voltage) {
     for (int i=0; i < NUM_EXCITATORY_RECEPTORS; i++) {
-        exc_input[i] = exc_input[i] *
+        // accum = accum * (accum - accum)
+//    	exc_input[i] = MULT_ROUND_STOCHASTIC_ACCUM(exc_input[i],
+//                (input_type->V_rev_E - membrane_voltage));
+    	exc_input[i] = exc_input[i] *
                 (input_type->V_rev_E - membrane_voltage);
     }
 }
@@ -89,6 +93,9 @@ static inline void input_type_convert_inhibitory_input_to_current(
         input_t *restrict inh_input, const input_type_t *input_type,
         state_t membrane_voltage) {
     for (int i=0; i < NUM_INHIBITORY_RECEPTORS; i++) {
+        // accum = accum * (accum - accum)
+//        inh_input[i] = MULT_ROUND_STOCHASTIC_ACCUM(-inh_input[i],
+//                (input_type->V_rev_I - membrane_voltage));
         inh_input[i] = -inh_input[i] *
                 (input_type->V_rev_I - membrane_voltage);
     }

neural_modelling/src/neuron/models/neuron_model_izh_impl.h

@@ -178,7 +178,7 @@ static inline state_t neuron_model_state_update(
     }
 
     input_t input_this_timestep = total_exc - total_inh
-            + external_bias + neuron->I_offset + current_offset;
+            - external_bias + neuron->I_offset + current_offset;
 
     // the best AR update so far
     rk2_kernel_midpoint(neuron->this_h, neuron, input_this_timestep);