routing_table.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 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 __ROUTING_TABLE_H__
#define __ROUTING_TABLE_H__
 
//=============================================================================
 
typedef struct key_mask_t {
    uint32_t key;
 
    uint32_t mask;
} key_mask_t;
 
typedef struct entry_t {
    key_mask_t key_mask;
 
    uint32_t route;
 
    uint32_t source;
} entry_t;
 
typedef struct table_t {
    uint32_t size;
 
    entry_t entries[];
} table_t;
 
table_t *table;
 
entry_t* routing_table_get_entry(uint32_t entry_id_to_find) {
    return &table->entries[entry_id_to_find];
}
 
int routing_table_get_n_entries(void) {
    return table->size;
}
 
void routing_table_remove_from_size(int size_to_remove) {
    table->size -= size_to_remove;
}
 
static inline void routing_table_put_entry(const entry_t* entry, int index) {
    entry_t* e_ptr = routing_table_get_entry(index);
    e_ptr->key_mask.key = entry->key_mask.key;
    e_ptr->key_mask.mask = entry->key_mask.mask;
    e_ptr->route = entry->route;
    e_ptr->source = entry->source;
}
 
static inline void routing_table_copy_entry(int new_index, int old_index) {
    entry_t* e_ptr = routing_table_get_entry(old_index);
    routing_table_put_entry(e_ptr, new_index);
}
 
static inline void swap_entries(int a, int b) {
    log_debug("swap %u %u", a, b);
    entry_t temp = *routing_table_get_entry(a);
    log_debug("before %u %u %u %u",
            temp.key_mask.key, temp.key_mask.mask, temp.route, temp.source);
    routing_table_put_entry(routing_table_get_entry(b), a);
    routing_table_put_entry(&temp, b);
    entry_t temp2 = *routing_table_get_entry(b);
    log_debug("before %u %u %u %u",
            temp2.key_mask.key, temp2.key_mask.mask, temp2.route, temp2.source);
}
 
//=============================================================================
//state for reduction in parameters being passed around
 
static inline uint32_t key_mask_get_xs(key_mask_t km) {
    return ~km.key & ~km.mask;
}
 
static inline unsigned int key_mask_count_xs(key_mask_t km) {
    return __builtin_popcount(key_mask_get_xs(km));
}
 
static inline bool key_mask_intersect(key_mask_t a, key_mask_t b) {
    return (a.key & b.mask) == (b.key & a.mask);
}
 
static inline key_mask_t key_mask_merge(key_mask_t a, key_mask_t b) {
    uint32_t new_xs = ~(a.key ^ b.key);
    key_mask_t c;
    c.mask = a.mask & b.mask & new_xs;
    c.key = (a.key | b.key) & c.mask;
 
    return c;
}
 
#define RTR_MC_SET_FAILED 0
 
 
typedef struct {
    uint32_t app_id;
 
    uint32_t compress_as_much_as_possible;
 
    uint32_t table_size;
 
    entry_t entries[];
} header_t;
 
void print_header(header_t *header) {
    log_debug("app_id = %d", header->app_id);
    log_debug("compress_as_much_as_possible = %d",
            header->compress_as_much_as_possible);
    log_debug("table_size = %d", header->table_size);
}
 
static void read_table(header_t *header) {
    table = MALLOC(
        sizeof(uint32_t) + (sizeof(entry_t) * header->table_size));
    if (table == NULL) {
        log_error("failed to allocate memory for routing tables");
        malloc_extras_terminate(EXIT_FAIL);
    }
    // Copy the size of the table
    table->size = header->table_size;
 
    // Copy in the routing table entries
    spin1_memcpy(table->entries, header->entries,
            sizeof(entry_t) * table->size);
}
 
bool load_routing_table(uint32_t app_id) {
    // Try to allocate sufficient room for the routing table.
    uint32_t entry_id = rtr_alloc_id(table->size, app_id);
    if (entry_id == 0) {
        log_error("Unable to allocate routing table of size %u\n", table->size);
        return FALSE;
    }
 
    // Load entries into the table (provided the allocation succeeded).
    // Note that although the allocation included the specified
    // application ID we also need to include it as the most significant
    // byte in the route (see `sark_hw.c`).
    for (uint32_t i = 0; i < table->size; i++) {
        entry_t entry = table->entries[i];
        uint32_t route = entry.route | (app_id << 24);
        uint success = rtr_mc_set(
            entry_id + i, entry.key_mask.key, entry.key_mask.mask, route);
        if (success == RTR_MC_SET_FAILED) {
            log_warning("failed to set a router table entry at index %d",
                    entry_id + i);
        }
    }
 
    // Indicate we were able to allocate routing table entries.
    return TRUE;
}
 
#endif  // __ROUTING_TABLE_H__