bit_field.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 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 __BIT_FIELD_H__
#define __BIT_FIELD_H__
 
#include <stdint.h>
#include <stdbool.h>
 
typedef uint32_t* bit_field_t;
 
#ifndef __SIZE_T__
typedef uint32_t size_t;
#define __SIZE_T__
#endif /*__SIZE_T__*/
 
#ifndef __INDEX_T__
typedef uint32_t index_t;
#define __INDEX_T__
#endif /*__INDEX_T__*/
 
#ifndef __COUNTER_T__
typedef uint32_t counter_t;
#define __COUNTER_T__
#endif /*__COUNTER_T__*/
 
static inline bool bit_field_test(
    bit_field_t b,
    index_t n)
{
    return (b[n >> 5] & (1 << (n & 0x1F))) != 0;
}
 
static inline void bit_field_clear(
    bit_field_t restrict b,
    index_t n)
{
    b[n >> 5] &= ~(1 << (n & 0x1F));
}
 
static inline void bit_field_set(
    bit_field_t restrict b,
    index_t n)
{
    b[n >> 5] |= 1 << (n & 0x1F);
}
 
static inline void not_bit_field(
    bit_field_t restrict b,
    size_t s)
{
    for ( ; s > 0; s--) {
        b[s-1] = ~ b[s-1];
    }
}
 
static inline void and_bit_fields(
    bit_field_t restrict b1,
    const bit_field_t restrict b2,
    size_t s)
{
    for ( ; s > 0; s--) {
        b1[s-1] &= b2[s-1];
    }
}
 
static inline void or_bit_fields(
    bit_field_t restrict b1,
    const bit_field_t restrict b2,
    size_t s)
{
    for ( ; s > 0; s--) {
        b1[s-1] |= b2[s-1];
    }
}
 
static inline void clear_bit_field(
    bit_field_t restrict b,
    size_t s)
{
    for ( ; s > 0; s--) {
        b[s-1] = 0;
    }
}
 
static inline void set_bit_field(
    bit_field_t restrict b,
    size_t s)
{
    for ( ; s > 0; s--) {
        b[s-1] = 0xFFFFFFFF;
    }
}
 
static inline bool empty_bit_field(
    const bit_field_t restrict b,
    size_t s)
{
    bool empty = true;
 
    for ( ; s > 0; s--) {
        empty = empty && (b[s-1] == 0);
    }
    return empty;
}
 
static inline bool nonempty_bit_field(
    const bit_field_t restrict b,
    size_t s)
{
    return !empty_bit_field(b, s);
}
 
static inline size_t get_bit_field_size(
    size_t bits)
{
    // **NOTE** in floating point terms this is ceil(num_neurons / 32)
    const uint32_t bits_to_words_shift = 5;
    const uint32_t bits_to_words_remainder = (1 << bits_to_words_shift) - 1;
 
    // Down shift number of bits to words
    uint32_t words = bits >> bits_to_words_shift;
 
    // If there was a remainder, add an extra word
    if ((bits & bits_to_words_remainder) != 0) {
        words++;
    }
    return words;
}
 
static inline int count_bit_field(
    const bit_field_t restrict b,
    size_t s)
{
    int sum = 0;
 
    for ( ; s > 0; s--) {
        sum += __builtin_popcount(b[s - 1]);
    }
    return sum;
}
 
void print_bit_field_bits(const bit_field_t restrict b, size_t s);
 
void print_bit_field(const bit_field_t restrict b, size_t s);
 
void random_bit_field(bit_field_t restrict b, size_t s);
 
bit_field_t bit_field_alloc(uint32_t n_atoms);
 
#endif /*__BIT_FIELD_H__*/