population_table.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 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 _POPULATION_TABLE_H_
#define _POPULATION_TABLE_H_
 
#include <common/neuron-typedefs.h>
#include <filter_info.h>
#include <neuron/synapse_row.h>
#include <debug.h>
 
 
#define BITS_PER_WORD 32
 
#define TOP_BIT_IN_WORD 31
 
#define NOT_IN_MASTER_POP_TABLE_FLAG -1
 
#define N_ADDRESS_BITS 24
 
#define INDIRECT_ADDRESS_SHIFT 4
 
typedef struct master_population_table_entry {
    uint32_t key;
    uint32_t mask;
    uint32_t start: 13;
    uint32_t n_colour_bits: 3;
    uint32_t count: 16;
    uint32_t core_mask: 16;
    uint32_t mask_shift: 16;
    uint32_t n_neurons: 16;
    uint32_t n_words: 16;
} master_population_table_entry;
 
typedef struct {
    uint32_t row_length : 8;
    uint32_t address : N_ADDRESS_BITS;
} address_list_entry;
 
#define INVALID_ADDRESS ((1 << N_ADDRESS_BITS) - 1)
 
typedef struct {
    uint32_t table_length;
    uint32_t addr_list_length;
    master_population_table_entry data[];
} pop_table_config_t;
 
typedef struct {
    // Updated with the address of the row
    synaptic_row_t row_address;
 
    // Updated with the number of bytes to read
    size_t n_bytes_to_transfer;
 
    // Updated with the spike colour
    uint32_t colour;
 
    // Updated with the spike colour mask
    uint32_t colour_mask;
} pop_table_lookup_result_t;
 
 
static inline uint32_t get_offset(address_list_entry entry) {
    return entry.address << INDIRECT_ADDRESS_SHIFT;
}
 
static inline uint32_t get_address(address_list_entry entry, uint32_t addr) {
    return get_offset(entry) + addr;
}
 
static inline uint32_t get_row_length(address_list_entry entry) {
    return entry.row_length + 1;
}
 
static inline uint32_t get_core_index(master_population_table_entry entry, spike_t spike) {
    return (spike >> entry.mask_shift) & entry.core_mask;
}
 
static inline uint32_t get_core_sum(master_population_table_entry entry, spike_t spike) {
    return get_core_index(entry, spike) * entry.n_neurons;
}
 
static inline uint32_t get_neuron_id(
        master_population_table_entry entry, spike_t spike) {
    return spike & ~entry.mask;
}
 
static inline uint32_t get_local_neuron_id(
        master_population_table_entry entry, spike_t spike) {
    return spike & ~(entry.mask | (entry.core_mask << entry.mask_shift));
}
 
static inline void get_row_addr_and_size(address_list_entry item,
        uint32_t synaptic_rows_base_address, uint32_t neuron_id,
        pop_table_lookup_result_t *result) {
    uint32_t row_length = get_row_length(item);
    uint32_t block_address = get_address(item, synaptic_rows_base_address);
    uint32_t stride = (row_length + N_SYNAPSE_ROW_HEADER_WORDS);
    uint32_t neuron_offset = neuron_id * stride * sizeof(uint32_t);
 
    result->row_address = (synaptic_row_t) (block_address + neuron_offset);
    result->n_bytes_to_transfer = stride * sizeof(uint32_t);
 
    log_debug("neuron_id = %u, block_address = 0x%.8x, "
            "row_length = %u, row_address = 0x%.8x, n_bytes = %u",
            neuron_id, block_address, row_length, result->row_address,
            result->n_bytes_to_transfer);
}
 
extern uint32_t ghost_pop_table_searches;
 
extern uint32_t invalid_master_pop_hits;
 
extern uint32_t failed_bit_field_reads;
 
extern uint32_t bit_field_filtered_packets;
 
extern uint16_t items_to_go;
 
bool population_table_setup(address_t table_address, uint32_t *row_max_n_words,
    uint32_t *master_pop_table_length,
    master_population_table_entry **master_pop_table,
    address_list_entry **address_list);
 
bool population_table_initialise(
        address_t table_address, address_t synapse_rows_address,
        uint32_t *row_max_n_words);
 
bool population_table_load_bitfields(filter_region_t *filter_region);
 
bool population_table_get_first_address(
        spike_t spike, pop_table_lookup_result_t *result);
 
static inline bool population_table_is_next(void) {
    return items_to_go > 0;
}
 
bool population_table_get_next_address(
        spike_t *spike, pop_table_lookup_result_t *result);
 
#endif // _POPULATION_TABLE_H_