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;
 
entry_t* routing_table_get_entry(uint32_t entry_id_to_find);
 
bool routing_table_get_entries(uint32_t start_entry, uint32_t n_entries,
        entry_t *output);
 
void routing_table_wait_for_last_transfer(void);
 
int routing_table_get_n_entries(void);
 
void routing_table_remove_from_size(int 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;
}
 
#endif  // __ROUTING_TABLE_H__