#include <BitSpec.h>

Collaboration diagram for GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >:

Classes
struct	Params

Public Types
using	value_type = Value
using	bits_type = Bitset<width,Clamped,Signed>
using	encoder_type = std::function<bits_type(Value)>
using	decoder_type = std::function<std::pair<Value,Value>(bits_type)>

Public Member Functions
constexpr	BitField (std::string_view name_, std::string_view auxvar, std::string_view description_, encoder_type encoder=nullptr, decoder_type decoder=nullptr, Value scale=0, Value offset=0, double centre=0.5, bool lower_inc=true)
constexpr	BitField (const Params &p)
Value	value (const SG::AuxElement &obj) const
Value	value (const SG::AuxElement &obj, bool truncate) const
AuxValue &	store (SG::AuxElement &obj, Value value) const
bits_type	encode (Value value) const
template<typename... Args>
bits_type	encode (const std::variant< Args... > &value) const
template<typename... Args>
std::pair< std::int64_t, std::pair< bool, bool > >	encodeAndCheckBoundary (const std::variant< Args... > &value) const
bits_type	bits (const SG::AuxElement &obj) const
std::pair< Value, Value >	range (bits_type bits) const
Value	decode (bits_type bits) const
template<std::size_t N>
bits_type	extract (const std::bitset< N > &packed) const
template<std::size_t N>
Value	decodeFrom (const std::bitset< N > &packed) const
template<std::size_t N>
void	decodeAndAssignFrom (const std::bitset< N > &packed, SG::AuxElement &obj) const
template<std::size_t N>
void	pack (std::bitset< N > &result, const SG::AuxElement &obj) const

Static Public Member Functions
static std::int64_t	code (bits_type bits)

Public Attributes
AuxSpec	auxspec
std::string_view	name
std::string_view	description

Static Public Attributes
static constexpr unsigned	lo = Lo
static constexpr unsigned	hi = Hi
static constexpr unsigned	width = Hi - Lo + 1
static constexpr auto	maxCode = bits_type::max
static constexpr auto	minCode = bits_type::min

Private Attributes
encoder_type	m_encoder
decoder_type	m_decoder
Value	m_valueoffset {}
SG::ConstAccessor< AuxValue >	m_acc
SG::Accessor< AuxValue >	m_wacc

Detailed Description

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>
class GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >

Definition at line 205 of file BitSpec.h.

Member Typedef Documentation

◆ bits_type

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

using GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::bits_type = Bitset<width,Clamped,Signed>

Definition at line 226 of file BitSpec.h.

◆ decoder_type

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

using GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::decoder_type = std::function<std::pair<Value,Value>(bits_type)>

Definition at line 232 of file BitSpec.h.

◆ encoder_type

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

using GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::encoder_type = std::function<bits_type(Value)>

Definition at line 231 of file BitSpec.h.

◆ value_type

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

using GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::value_type = Value

Definition at line 225 of file BitSpec.h.

Constructor & Destructor Documentation

◆ BitField() [1/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::BitField	(	std::string_view	name_,
		std::string_view	auxvar,
		std::string_view	description_,
		encoder_type	encoder = nullptr,
		decoder_type	decoder = nullptr,
		Value	scale = 0,
		Value	offset = 0,
		double	centre = 0.5,
		bool	lower_inc = true )

inlineconstexpr

Definition at line 234 of file BitSpec.h.

                : auxspec(AuxSpec::parse(auxvar)),
                  name(name_),
                  description(description_),
                  m_encoder(encoder),
                  m_decoder(decoder),
                  m_acc(std::string{auxspec.name}), m_wacc(std::string{auxspec.name}) {
                if(!m_encoder && !m_decoder && scale) {
                    if constexpr (Signed) {
                        // need to cast to signed int, as casting a negative float to unsigned int is undefined behaviour
                        // was previously then explicitly casting to uint64_t when bits_type was a std::bitset
                        // which worked. But now using clampable bitsets, the behaviour isn't quite the same
                        if(lower_inc) {
                            m_encoder = [scale, offset](Value v) {
                                return bits_type{static_cast<int64_t>(std::floor((v - offset) / scale))};
                            };
                        } else {
                            m_encoder = [scale, offset](Value v) {
                                return bits_type{static_cast<int64_t>((std::ceil((v - offset) / scale) - 1))};
                            };
                        }
                    } else {
                        m_encoder = [scale, offset, lower_inc](Value v) {
                            return bits_type{static_cast<uint64_t>(lower_inc ? std::floor((v - offset) / scale) : (
                                    std::ceil((v - offset) / scale) - 1))};
                        };
                    }
                    m_decoder = [scale,offset](bits_type bits) -> std::pair<Value,Value> {
                            const double c = static_cast<double>(code(bits));
                            return {static_cast<Value>(offset + c*scale),
                                    static_cast<Value>(offset + (c+1.0)*scale) };
                    };
                }
            if constexpr (std::is_arithmetic_v<Value> && !std::is_same_v<Value, bool>)
            {
                m_valueoffset = centre;
            }
        }

◆ BitField() [2/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::BitField ( const Params & p )

inlineconstexpr

Definition at line 294 of file BitSpec.h.

294: BitField(p.name,p.auxvar.empty()?p.name:p.auxvar,p.description,p.encoder,p.decoder,p.scale,p.offset,p.centre,p.lower_incl) { }

GlobalSim::BitField::BitField

constexpr BitField(std::string_view name_, std::string_view auxvar, std::string_view description_, encoder_type encoder=nullptr, decoder_type decoder=nullptr, Value scale=0, Value offset=0, double centre=0.5, bool lower_inc=true)

Definition BitSpec.h:234

Member Function Documentation

◆ bits()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

bits_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::bits ( const SG::AuxElement & obj ) const

inline

Definition at line 427 of file BitSpec.h.

                                                      {
            return encode(value(obj));
        }

◆ code()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

std::int64_t GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::code ( bits_type bits )

inlinestatic

Definition at line 413 of file BitSpec.h.

                                               {
            auto value = bits.to_ullong();
            if constexpr (Signed) {
                if (bits[width - 1]) {
                    value -= (std::uint64_t{1} << width);
                }
            }
            return static_cast<std::int64_t>(value);
        }

◆ decode()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

Value GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::decode ( bits_type bits ) const

inline

Definition at line 446 of file BitSpec.h.

                                           {
            const auto [lo,hi] = range(bits);
            if (lo == hi) {
                return lo;
            }
 
            if constexpr (std::is_arithmetic_v<Value> && !std::is_same_v<Value, bool>) {
                return (lo+m_valueoffset*(hi-lo));
            } else {
                // No well-defined midpoint for this Value type -- fall back to
                // the lower bound rather than attempting arithmetic on it.
                return lo;
            }
        }

◆ decodeAndAssignFrom()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<std::size_t N>

void GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::decodeAndAssignFrom	(	const std::bitset< N > &	packed,
		SG::AuxElement &	obj ) const

inline

Definition at line 487 of file BitSpec.h.

                                                                                       {
            store( obj, decode(extract(packed)));
        }

◆ decodeFrom()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<std::size_t N>

Value GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::decodeFrom ( const std::bitset< N > & packed ) const

inline

Definition at line 482 of file BitSpec.h.

                                                            {
            return decode(extract(packed));
        }

◆ encode() [1/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<typename... Args>

bits_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::encode ( const std::variant< Args... > & value ) const

inline

Definition at line 372 of file BitSpec.h.

                                                                 {
            return std::visit(
                    [this](const auto& v) -> bits_type {
                        using T = std::decay_t<decltype(v)>;
 
                        if constexpr (std::is_convertible_v<T, Value>) {
                        return encode(
                                static_cast<Value>(v));
                    }
                        else {
                        throw std::invalid_argument(
                                "Variant alternative cannot be converted "
                                "to BitField value type");
                    }
                    },
                    value);
        }

◆ encode() [2/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

bits_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::encode ( Value value ) const

inline

Definition at line 356 of file BitSpec.h.

                                            {
            if (m_encoder)
                return m_encoder(value);
 
            // Default behaviour: integral conversion.
 
            // should we check for out-of-range given size of bitset?
 
            return bits_type{
                    static_cast<unsigned long long>(value)
            };
        }

◆ encodeAndCheckBoundary()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<typename... Args>

std::pair< std::int64_t, std::pair< bool, bool > > GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::encodeAndCheckBoundary ( const std::variant< Args... > & value ) const

inline

Definition at line 393 of file BitSpec.h.

                                                                                                              {
            return std::visit(
                    [this](const auto& v) -> std::pair<std::int64_t,std::pair<bool,bool>> {
                        using T = std::decay_t<decltype(v)>;
 
                        if constexpr (std::is_convertible_v<T, Value>) {
                            auto bits = encode(static_cast<Value>(v));
                            auto r = range(bits);
                            return {code(bits),{v==r.first,v==r.second}};
                        } else {
                            throw std::invalid_argument(
                                "Variant alternative cannot be converted "
                                "to BitField value type");
                    }
                    },
                    value);
        }

◆ extract()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<std::size_t N>

bits_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::extract ( const std::bitset< N > & packed ) const

inline

Definition at line 466 of file BitSpec.h.

                                                             {
            static_assert(Hi < N, "BitField extends beyond the specification width");
 
            bits_type result;
 
            for (unsigned i = 0; i < width; ++i)
                result[i] = packed[Lo + i];
 
            return result;
        }

◆ pack()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

template<std::size_t N>

void GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::pack	(	std::bitset< N > &	result,
		const SG::AuxElement &	obj ) const

inline

Definition at line 496 of file BitSpec.h.

                                               {
            static_assert(
                    Hi < N,
                    "BitField extends beyond the specification width");
 
            const bits_type field_bits = bits(obj);
 
            for (unsigned i = 0; i < width; ++i)
                result[Lo + i] = field_bits[i];
        }

◆ range()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

std::pair< Value, Value > GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::range ( bits_type bits ) const

inline

Definition at line 435 of file BitSpec.h.

                                                          {
            if (m_decoder)
                return m_decoder(bits);
            const Value v = static_cast<Value>(code(bits));
            return { v, v };
        }

◆ store()

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

AuxValue & GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::store	(	SG::AuxElement &	obj,
		Value	value ) const

inline

Definition at line 330 of file BitSpec.h.

                                                              {
            if constexpr (std::is_integral_v<AuxValue>)
            { // ensures have bitwise operators, has_mask is not constexpr so must hide this from invalid AuxValue types
                // leaving this commented as may revert to constexpr again at some point
                //            if constexpr (has_mask) {
                //                auto& val = m_wacc(obj);
                //                val = (val & ~Mask) | ((value << shift) & Mask);
                if (auxspec.has_mask) {
                    auto &val = m_wacc(obj);
                    //avoid unintended sign extension, make everything unsigned
                    using unsigned_aux_type = std::make_unsigned_t<AuxValue>;
                    const auto mask = static_cast<unsigned_aux_type>(auxspec.mask);
                    const auto current = static_cast<unsigned_aux_type>(val);
                    const auto encoded = (static_cast<unsigned_aux_type>(value) << auxspec.shift) & mask;
                    val = static_cast<AuxValue>((current & ~mask) | encoded);
                    return val;
                }
            }
            return (m_wacc(obj) = value);
 
        }

◆ value() [1/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

Value GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::value ( const SG::AuxElement & obj ) const

inline

Definition at line 308 of file BitSpec.h.

                                                   {
 
            if constexpr (std::is_integral_v<AuxValue>)
            { // ensures have bitwise operators
 
                /*if constexpr(has_mask) {
                    return (m_acc(obj) & Mask) >> shift;*/
                if (auxspec.has_mask) {
                    return decode((m_acc(obj) & auxspec.mask) >> auxspec.shift);
                }
            }
 
            return m_acc(obj);
 
        }

◆ value() [2/2]

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

Value GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::value	(	const SG::AuxElement &	obj,
		bool	truncate ) const

inline

Definition at line 325 of file BitSpec.h.

                                                                  {
            if(!truncate) return value(obj);
            return decode(encode(value(obj)));
        }

Member Data Documentation

◆ auxspec

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

AuxSpec GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::auxspec

Definition at line 509 of file BitSpec.h.

◆ description

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

std::string_view GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::description

Definition at line 511 of file BitSpec.h.

◆ hi

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

unsigned GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::hi = Hi

staticconstexpr

Definition at line 213 of file BitSpec.h.

◆ lo

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

unsigned GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::lo = Lo

staticconstexpr

Definition at line 212 of file BitSpec.h.

◆ m_acc

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

SG::ConstAccessor<AuxValue> GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::m_acc

private

Definition at line 520 of file BitSpec.h.

◆ m_decoder

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

decoder_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::m_decoder

private

Definition at line 517 of file BitSpec.h.

◆ m_encoder

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

encoder_type GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::m_encoder

private

Definition at line 516 of file BitSpec.h.

◆ m_valueoffset

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

Value GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::m_valueoffset {}

private

Definition at line 518 of file BitSpec.h.

518{}; // used by decode to return a value in the encoder range

◆ m_wacc

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

SG::Accessor<AuxValue> GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::m_wacc

private

Definition at line 521 of file BitSpec.h.

◆ maxCode

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

auto GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::maxCode = bits_type::max

staticconstexpr

Definition at line 228 of file BitSpec.h.

◆ minCode

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

auto GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::minCode = bits_type::min

staticconstexpr

Definition at line 229 of file BitSpec.h.

◆ name

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

std::string_view GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::name

Definition at line 510 of file BitSpec.h.

◆ width

template<unsigned Lo, unsigned Hi, typename AuxValue, typename Value = AuxValue, bool Signed = false, bool Clamped = true>

unsigned GlobalSim::BitField< Lo, Hi, AuxValue, Value, Signed, Clamped >::width = Hi - Lo + 1

staticconstexpr

Definition at line 214 of file BitSpec.h.

The documentation for this class was generated from the following file:

BitSpec.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ bits_type

◆ decoder_type

◆ encoder_type

◆ value_type

Constructor & Destructor Documentation

◆ BitField() [1/2]

◆ BitField() [2/2]

Member Function Documentation

◆ bits()

◆ code()

◆ decode()

◆ decodeAndAssignFrom()

◆ decodeFrom()

◆ encode() [1/2]

◆ encode() [2/2]

◆ encodeAndCheckBoundary()

◆ extract()

◆ pack()

◆ range()

◆ store()

◆ value() [1/2]

◆ value() [2/2]

Member Data Documentation

◆ auxspec

◆ description

◆ hi

◆ lo

◆ m_acc

◆ m_decoder

◆ m_encoder

◆ m_valueoffset

◆ m_wacc

◆ maxCode

◆ minCode

◆ name

◆ width