connection_generator_fixed_prob.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 <synapse_expander/rng.h>
#include <synapse_expander/generator_types.h>
 
// Eclipse does *NOT* like this type!
typedef unsigned long fract probability_t;
 
struct fixed_prob_params {
    uint32_t allow_self_connections;
    probability_t probability;
};
 
struct fixed_prob {
    struct fixed_prob_params params;
};
 
static void *connection_generator_fixed_prob_initialise(void **region) {
    // Allocate memory for the data
    struct fixed_prob *obj = spin1_malloc(sizeof(struct fixed_prob));
 
    // Copy the parameters in
    struct fixed_prob_params *params_sdram = *region;
    obj->params = *params_sdram;
    *region = &params_sdram[1];
 
    log_debug("Fixed Probability Connector, allow self connections = %u, "
            "probability = %k",
            obj->params.allow_self_connections, (accum) obj->params.probability);
    return obj;
}
 
static void connection_generator_fixed_prob_free(void *generator) {
    sark_free(generator);
}
 
static bool connection_generator_fixed_prob_generate(
        void *generator, uint32_t pre_lo, uint32_t pre_hi,
        uint32_t post_lo, uint32_t post_hi, UNUSED uint32_t post_index,
        uint32_t post_slice_start, uint32_t post_slice_count,
        unsigned long accum weight_scale, accum timestep_per_delay,
        param_generator_t weight_generator, param_generator_t delay_generator,
        matrix_generator_t matrix_generator) {
    struct fixed_prob *obj = generator;
 
    // Get the actual ranges to generate within
    uint32_t post_start = max(post_slice_start, post_lo);
    uint32_t post_end = min(post_slice_start + post_slice_count - 1, post_hi);
 
    for (uint32_t pre = pre_lo; pre <= pre_hi; pre++) {
        for (uint32_t post = post_start; post <= post_end; post++) {
            if (pre == post && !obj->params.allow_self_connections) {
                continue;
            }
 
            // Generate a random number
            probability_t value = ulrbits(rng_generator(core_rng));
 
            // If less than our probability, generate a connection
            if (value < obj->params.probability) {
                uint32_t local_post = post - post_slice_start;
                accum weight = param_generator_generate(weight_generator);
                uint16_t delay = rescale_delay(
                        param_generator_generate(delay_generator), timestep_per_delay);
                if (!matrix_generator_write_synapse(matrix_generator, pre, local_post,
                        weight, delay, weight_scale)) {
                    // Retry not useful here
                    log_warning("Could not add to matrix!");
                }
            }
        }
    }
    return true;
}