BEMTester Class Reference

#include <BEMTester.hh>

Collaboration diagram for BEMTester:

Static Public Member Functions
static bool	canAddComponentEncoding (SlotField &field, unsigned int encoding, unsigned int extraBits)
static bool	canAddComponentPriorityEncoding (MoveSlot &slot, unsigned int encoding, unsigned int extraBits, int offset=0)
static bool	canAddPortEncoding (SocketCodeTable &table, unsigned int encoding, unsigned int extraBits)

Static Private Member Functions
static int	commonBitCount (unsigned int enc1, unsigned int extraBits1, unsigned int enc2, unsigned int extraBits2, int alignment)
static int	calculateAlignment (unsigned int enc1, unsigned int enc2, const SlotField &field)
static bool	fieldsOverlap (const InstructionField &with, unsigned int toFieldWidth, int toFieldPos)
static bool	fieldsOverlap (unsigned width1, int pos1, unsigned width2, int pos2)
static bool	conflictsWithGuardEncoding (const GuardField &field, unsigned int encoding, unsigned int width, int offset)
static bool	conflictsWithSourceEncodings (const SourceField &field, unsigned int encoding, unsigned int width, int offset)
static bool	conflictsWithDestinationEncodings (const DestinationField &field, unsigned int encoding, unsigned int width, int offset)
static bool	conflictsWithSocketTableEncodings (const SocketCodeTable &scTable, unsigned int encoding, unsigned int width, int offset)
static std::tuple< unsigned, unsigned, int >	splitEncoding (unsigned encoding, unsigned encodingWidth, unsigned targetWidth, int offsetToTarget)
static std::tuple< unsigned, unsigned, int >	splitEncodingTo (const SocketEncoding &socketEncoding, unsigned encoding, unsigned encodingWidth, int offsetToTarget)

Detailed Description

BEMTester is a helper class which provides useful validity checking methods for the BEM module itself and for other clients.

Definition at line 53 of file BEMTester.hh.

Member Function Documentation

calculateAlignment()

int BEMTester::calculateAlignment ( unsigned int  enc1Width, unsigned int  enc2Width, const SlotField &  field  )

staticprivate

Calculates the alignment of encodings that has the given widths when they are added to the given slot field.

Parameters

enc1Width	Width of the first encoding.
enc2Width	Width of the second encoding.
field	The slot field.

Returns

The alignment.

Definition at line 352 of file BEMTester.cc.

                            {
 
    if (field.componentIDPosition() == BinaryEncoding::RIGHT) {
        return 0;
    } else {
        return enc2Width - enc1Width;
    }
}

References SlotField::componentIDPosition(), and BinaryEncoding::RIGHT.

Referenced by canAddComponentEncoding().

Here is the call graph for this function:

canAddComponentEncoding()

bool BEMTester::canAddComponentEncoding ( SlotField &  field, unsigned int  encoding, unsigned int  extraBits  )

static

Tests whether the given encoding can be added to the given slot field.

The encoding can not be added to the slot field if some other socket encoding, bridge encoding, immediate encoding or NOP encoding has exactly the same bits in same positions. For example, if socket (and bridge) ID's are in the left end of the slot field, the encodings '1001' and '10' would conflict, since in both cases the two leftmost bits in the field are '10'.

Parameters

field	The slot field.
encoding	The encoding.
extraBits	The number of extra bits in the encoding.

Returns

True if the encoding can be added to the slot field, otherwise false.

Definition at line 73 of file BEMTester.cc.

                            {
 
    unsigned int encodingWidth = MathTools::bitLength(encoding) + 
        extraBits;
 
    int socketEncodings = field.socketEncodingCount();
    for (int i = 0; i < socketEncodings; i++) {
        SocketEncoding& existingEnc = field.socketEncoding(i);
        int alignment = calculateAlignment(
            encodingWidth, existingEnc.socketIDWidth(), field);
        int commonBits = commonBitCount(
            encoding, extraBits, existingEnc.encoding(),
            existingEnc.extraBits(), alignment);
        if (commonBits == static_cast<int>(MathTools::bitLength(encoding))
                + static_cast<int>(extraBits) || 
            commonBits == existingEnc.socketIDWidth()) {
            return false;
        }
    }
 
    SourceField* sField = dynamic_cast<SourceField*>(&field);
    if (sField != NULL) {
        int bridgeEncodings = sField->bridgeEncodingCount();
        for (int i = 0; i < bridgeEncodings; i++) {
            BridgeEncoding& existingEnc = sField->bridgeEncoding(i);
            int alignment = calculateAlignment(
                encodingWidth, existingEnc.width(), field);
            int commonBits = commonBitCount(
                encoding, extraBits, existingEnc.encoding(),
                existingEnc.extraBits(), alignment);
            if (commonBits == static_cast<int>(
                    MathTools::bitLength(encoding)) + 
                    static_cast<int>(extraBits) || 
                commonBits == existingEnc.width()) {
                return false;
            }
        }
        
        if (sField->hasImmediateEncoding()) {
            ImmediateEncoding& immEnc = sField->immediateEncoding();
            int alignment = calculateAlignment(
                encodingWidth, immEnc.width(), field);
            int commonBits = commonBitCount(
                encoding, extraBits, immEnc.encoding(), immEnc.extraBits(),
                alignment);
            if (commonBits ==
                    static_cast<int>(MathTools::bitLength(encoding)) +
                        static_cast<int>(extraBits) ||
                commonBits == immEnc.width()) {
                return false;
            }
        }
 
        if (sField->hasNoOperationEncoding()) {
            NOPEncoding& nopEnc = sField->noOperationEncoding();
            int alignment = calculateAlignment(
                encodingWidth, nopEnc.width(), field);
            int commonBits = commonBitCount(
                encoding, extraBits, nopEnc.encoding(), nopEnc.extraBits(),
                alignment);
            if (commonBits == static_cast<int>(
                    MathTools::bitLength(encoding)) +
                    static_cast<int>(extraBits) || 
                commonBits == nopEnc.width()) {
                return false;
            }
        }
 
    }
    return true;
}

References MathTools::bitLength(), SourceField::bridgeEncoding(), SourceField::bridgeEncodingCount(), calculateAlignment(), commonBitCount(), Encoding::encoding(), Encoding::extraBits(), SourceField::hasImmediateEncoding(), SlotField::hasNoOperationEncoding(), SourceField::immediateEncoding(), SlotField::noOperationEncoding(), SlotField::socketEncoding(), SlotField::socketEncodingCount(), SocketEncoding::socketIDWidth(), Encoding::width(), and ImmediateEncoding::width().

Referenced by SourceField::addBridgeEncoding(), SlotField::addSocketEncoding(), SourceField::setImmediateEncoding(), and SlotField::setNoOperationEncoding().

Here is the call graph for this function:

canAddComponentPriorityEncoding()

bool BEMTester::canAddComponentPriorityEncoding ( MoveSlot &  slot, unsigned int  encoding, unsigned int  extraBits, int  offset = 0  )

static

Tests whether the given priority encoding can be added to the given move slot field.

The encoding can be added to the slot if it distinguishable from the other encodings in the slot. The encoding is distinguishable if there is no guard, source and destination field encoding combination that could be misunderstood as the given encoding.

The tested encoding is treated as it has higher priority in decoding. That is, is the given encoding is present in the move slot, then any other encoding bits (non-overlapping with the given encoding) in the slot does not have effect.

The tested encoding can cross boundaries of guard, source and destination fields, overlapping multiple fields. A par of the encoding (i.e. overlapping some slot field) may be indistinguishable as long as some other parts are distinguishable.

Parameters

slot	The slot where the encoding could be added.
encoding	The encoding value. Avoid using zero value since its bit width is zero too. Instead, use one extrabit denote zero value.
extraBits	The extra bits (zeroes) of the the encoding at the left side.
offset	The position of the encoding from LSB position of the slot. Zero means that the given encoding is right aligned in the slot.

Returns

True if the encoding is distinguishable from the other encodings and, therefore, can be added to the slot.

Definition at line 180 of file BEMTester.cc.

                {
    bool canAdd = false;
    int encWidth = BEMTools::encodingWidth(encoding, extraBits);
    unsigned truncatedEnc;
    unsigned truncatedWidth;
    int offsetInField;
 
    if (encWidth + offset > slot.width()) {
        // The move NOP encoding can be always added if (part of the) it is
        // located out side of the move slot fields.
        // note: this assumes that the move slot does not have other kinds of
        // move encodings.
        return true;
    }
 
    if (fieldsOverlap(slot.guardField(), encWidth, offset)) {
        std::tie(truncatedEnc, truncatedWidth, offsetInField) = splitEncoding(
            encoding, encWidth, slot.guardField().width(),
            offset - slot.guardField().bitPosition());
 
        canAdd = canAdd || !conflictsWithGuardEncoding(
                               slot.guardField(), truncatedEnc,
                               truncatedWidth, offsetInField);
    }
 
    if (fieldsOverlap(slot.sourceField(), encWidth, offset)) {
        const SourceField& field = slot.sourceField();
        std::tie(truncatedEnc, truncatedWidth, offsetInField) = splitEncoding(
            encoding, encWidth, field.width(), offset - field.bitPosition());
 
        canAdd =
            canAdd || !conflictsWithSourceEncodings(
                          field, truncatedEnc, truncatedWidth, offsetInField);
    }
 
    if (fieldsOverlap(slot.destinationField(), encWidth, offset)) {
        const DestinationField& field = slot.destinationField();
        std::tie(truncatedEnc, truncatedWidth, offsetInField) = splitEncoding(
            encoding, encWidth, field.width(), offset - field.bitPosition());
 
        canAdd =
            canAdd || !conflictsWithDestinationEncodings(
                          field, truncatedEnc, truncatedWidth, offsetInField);
    }
 
    return canAdd;
}

References InstructionField::bitPosition(), conflictsWithDestinationEncodings(), conflictsWithGuardEncoding(), conflictsWithSourceEncodings(), MoveSlot::destinationField(), BEMTools::encodingWidth(), fieldsOverlap(), MoveSlot::guardField(), MoveSlot::sourceField(), splitEncoding(), GuardField::width(), MoveSlot::width(), SlotField::width(), and SourceField::width().

Here is the call graph for this function:

canAddPortEncoding()

bool BEMTester::canAddPortEncoding ( SocketCodeTable &  table, unsigned int  encoding, unsigned int  extraBits  )

static

Tells whether the given port encoding can be added to the given socket code table.

The given encoding is be ambiguous with some other FU port encoding or RF port encoding in the socket code table if all the bits of the encoding are the same with the bits of another encoding in the same position of the field. For example, encodings 1011 and 11 are ambiguous if the LSBs of the encodings are in the same position.

Parameters

table	The socket code table.
encoding	The encoding.
extraBits	The number of extra bits in the encoding.

Returns

True if the encoding can be added to the socket code table, otherwise false.

Definition at line 247 of file BEMTester.cc.

                            {
 
    int encodingWidth = MathTools::bitLength(encoding) + extraBits;
 
    int fuPortEncodings = table.fuPortCodeCount();
    for (int i = 0; i < fuPortEncodings; i++) {
        FUPortCode& code = table.fuPortCode(i);
        int commonBits = commonBitCount(
            encoding, extraBits, code.encoding(), code.extraBits(), 
            code.encodingWidth() - encodingWidth);
        if (commonBits == encodingWidth ||
            commonBits == code.encodingWidth()) {
            return false;
        }
    }
 
    int rfPortEncodings = table.rfPortCodeCount();
    for (int i = 0; i < rfPortEncodings; i++) {
        RFPortCode& code = table.rfPortCode(i);
        int commonBits = commonBitCount(
            encoding, extraBits, code.encoding(), code.extraBits(),
            code.encodingWidth() - encodingWidth);
        if (commonBits == encodingWidth ||
            commonBits == code.encodingWidth()) {
            return false;
        }
    }
 
    int iuPortEncodings = table.iuPortCodeCount();
    for (int i = 0; i < iuPortEncodings; i++) {
        IUPortCode& code = table.iuPortCode(i);
        int commonBits = commonBitCount(
            encoding, extraBits, code.encoding(), code.extraBits(),
            code.encodingWidth() - encodingWidth);
        if (commonBits == encodingWidth ||
            commonBits == code.encodingWidth()) {
            return false;
        }
    }
 
    return true;
}

References MathTools::bitLength(), commonBitCount(), PortCode::encoding(), PortCode::encodingWidth(), PortCode::extraBits(), SocketCodeTable::fuPortCode(), SocketCodeTable::fuPortCodeCount(), SocketCodeTable::iuPortCode(), SocketCodeTable::iuPortCodeCount(), SocketCodeTable::rfPortCode(), and SocketCodeTable::rfPortCodeCount().

Referenced by SocketCodeTable::addFUPortCode(), SocketCodeTable::addIUPortCode(), and SocketCodeTable::addRFPortCode().

Here is the call graph for this function:

commonBitCount()

int BEMTester::commonBitCount ( unsigned int  enc1, unsigned int  extraBits1, unsigned int  enc2, unsigned int  extraBits2, int  alignment  )

staticprivate

Tells the number of common bits in the same positions in the given encodings. The LSB bit of the encodings may not be in the same position. That is defined by the alignment parameter.

Parameters

enc1	The first encoding.
extraBits1	The number of extra zero bits in the first encoding.
enc2	The second encoding.
extraBits2	The number of extra zero bits in the second encoding.
alignment	The number of bits the second encoding has in the right side of the first encoding (negative if the LSB bit of the second encoding is on the left side of the LSB bit of the first encoding).

Definition at line 309 of file BEMTester.cc.

                   {
 
    int commonBits(0);
 
    int enc1Offset = 0;
    int enc2Offset = 0;
 
    if (alignment > 0) {
        enc2Offset = alignment;
    } else if (alignment < 0) {
        enc1Offset = alignment * (-1);
    }
 
    int maxEnc1Offset = MathTools::bitLength(enc1) + extraBits1 - 1;
    int maxEnc2Offset = MathTools::bitLength(enc2) + extraBits2 - 1;
 
    while (enc1Offset <= maxEnc1Offset && enc2Offset <= maxEnc2Offset) {
        if (MathTools::bit(enc1, enc1Offset) == 
            MathTools::bit(enc2, enc2Offset)) {
            commonBits++;
        }
        enc1Offset++;
        enc2Offset++;
    }
 
    return commonBits;
}

References MathTools::bit(), and MathTools::bitLength().

Referenced by canAddComponentEncoding(), and canAddPortEncoding().

Here is the call graph for this function:

conflictsWithDestinationEncodings()

bool BEMTester::conflictsWithDestinationEncodings ( const DestinationField &  field, unsigned int  encoding, unsigned int  width, int  offset  )

staticprivate

Checks that the given encoding and others in the field can be distinguished from each other.

Parameters

field	The destination field.
encoding	The encoding.
width	The width of the encoding where the encoding value is right aligned.
offset	The relative position of the encoding to the field's LSB. Positive shifts the encoding towards MSB and vice versa.

Returns

True if the encoding can not be distinguished from another encoding.

Definition at line 560 of file BEMTester.cc.

                {
    unsigned truncatedEncoding;
    unsigned truncatedWidth;
    unsigned truncatedOffset;
 
    for (int i = 0; i < field.socketEncodingCount(); i++) {
        const SocketEncoding& socketEnc = field.socketEncoding(i);
        std::tie(truncatedEncoding, truncatedWidth, truncatedOffset) =
            splitEncodingTo(socketEnc, encoding, width, offset);
 
        bool socketIDOverlap = fieldsOverlap(
            socketEnc.socketIDWidth(), socketEnc.socketIDPosition(), width,
            offset);
        bool socketIDMatch = MathTools::bitFieldsEquals(
            socketEnc.encoding(), truncatedOffset, truncatedEncoding, 0,
            truncatedWidth);
 
        const SocketCodeTable& scTable = socketEnc.socketCodes();
        // Get the part that overlaps with port codes.
        std::tie(truncatedEncoding, truncatedWidth, truncatedOffset) =
            splitEncoding(
                encoding, width, scTable.width(),
                offset - socketEnc.socketCodePosition());
 
        bool socketCodeOverlap = truncatedWidth > 0;
        bool socketCodeMatch = conflictsWithSocketTableEncodings(
            scTable, truncatedEncoding, truncatedWidth, truncatedOffset);
 
        if (socketIDOverlap) {
            if (socketCodeOverlap && socketIDMatch && socketCodeMatch) {
                return true;
            } else if (!socketCodeOverlap && socketIDMatch) {
                return true;
            }
        } else if (socketCodeOverlap && socketCodeMatch) {
            return true;
        }
    }
 
    return false;
}

References MathTools::bitFieldsEquals(), conflictsWithSocketTableEncodings(), Encoding::encoding(), fieldsOverlap(), SocketEncoding::socketCodePosition(), SocketEncoding::socketCodes(), SlotField::socketEncoding(), SlotField::socketEncodingCount(), SocketEncoding::socketIDPosition(), SocketEncoding::socketIDWidth(), splitEncoding(), splitEncodingTo(), and SocketCodeTable::width().

Referenced by canAddComponentPriorityEncoding().

Here is the call graph for this function:

conflictsWithGuardEncoding()

bool BEMTester::conflictsWithGuardEncoding ( const GuardField &  field, unsigned int  encoding, unsigned int  width, int  offset  )

staticprivate

Checks that the given encoding and others in the field can be distinguished from each other.

Parameters

field	The guard field.
encoding	The encoding.
width	The width of the encoding where the encoding value is right aligned.
offset	The relative position of the encoding to the field's LSB. Positive shifts the encoding towards MSB and vice versa.

Returns

True if the encoding can not be distinguished from another encoding.

Definition at line 430 of file BEMTester.cc.

                {
    for (int i = 0; i < field.gprGuardEncodingCount(); i++) {
        const GPRGuardEncoding& grdEnc = field.gprGuardEncoding(i);
 
        if (MathTools::bitFieldsEquals(
                grdEnc.encoding(), 0, encoding, offset, field.width())) {
            return true;
        }
    }
 
    for (int i = 0; i < field.fuGuardEncodingCount(); i++) {
        const FUGuardEncoding& grdEnc = field.fuGuardEncoding(i);
 
        if (MathTools::bitFieldsEquals(
                grdEnc.encoding(), 0, encoding, offset, field.width())) {
            return true;
        }
    }
 
    if (field.hasUnconditionalGuardEncoding(false)) {
        const UnconditionalGuardEncoding& grdEnc =
            field.unconditionalGuardEncoding(false);
 
        if (MathTools::bitFieldsEquals(
                grdEnc.encoding(), 0, encoding, offset, field.width())) {
            return true;
        }
    }
 
    if (field.hasUnconditionalGuardEncoding(true)) {
        const UnconditionalGuardEncoding& grdEnc =
            field.unconditionalGuardEncoding(true);
 
        if (MathTools::bitFieldsEquals(
                grdEnc.encoding(), 0, encoding, offset, field.width())) {
            return true;
        }
    }
 
    return false;
}

References MathTools::bitFieldsEquals(), GuardEncoding::encoding(), GuardField::fuGuardEncoding(), GuardField::fuGuardEncodingCount(), GuardField::gprGuardEncoding(), GuardField::gprGuardEncodingCount(), GuardField::hasUnconditionalGuardEncoding(), GuardField::unconditionalGuardEncoding(), and GuardField::width().

Referenced by canAddComponentPriorityEncoding().

Here is the call graph for this function:

conflictsWithSocketTableEncodings()

bool BEMTester::conflictsWithSocketTableEncodings ( const SocketCodeTable &  scTable, unsigned int  encoding, unsigned int  width, int  offset  )

staticprivate

Checks that the given encoding and others in the socket table can be distinguished from each other.

Parameters

scTable	The socket code table.
encoding	The encoding.
width	The width of the encoding where the encoding value is right aligned.
offset	The relative position of the encoding to the field's LSB. Positive shifts the encoding towards MSB and vice versa.

Returns

True if the encoding can not be distinguished from another encoding.

Definition at line 618 of file BEMTester.cc.

                {
    // The conflict checking assumes that port code is encoded as:
    //      |<-   width  ->|
    //      |   encoding   |<- (offset > 0) ------------------------|
    // | extrabits | port code encoding | unused bits | index width |
    // |<-               socket code table width                  ->|
    // msb                                                     lsb: 0
    // note: port code encoding is left aligned and index bits are right
    //       aligned, leaving unused bits between them if table width
    //       is wider than the port code width.
 
    for (int i = 0; i < scTable.portCodeCount(); i++) {
        const PortCode& portCode = scTable.portCode(i);
        // Check port code encoding
        if (portCode.encodingWidth() > 0) {
            // note: extrabits of SocketCodeTable are not considered.
            if (MathTools::bitFieldsEquals(
                    encoding, 0, portCode.encoding(),
                    portCode.encodingWidth() - width, width)) {
                return true;
            }
        }
 
        // Check index part
        if (portCode.indexWidth() > 0) {
            if (fieldsOverlap(portCode.indexWidth(), 0, width, offset)) {
                // todo/note: check if suggested encoding lands on unused
                // index (when isMaxIndexSet() == true. Currently the feature
                // is not used anywhere).
                return true;
            }
        }
    }
    return false;
}

References MathTools::bitFieldsEquals(), PortCode::encoding(), PortCode::encodingWidth(), fieldsOverlap(), PortCode::indexWidth(), SocketCodeTable::portCode(), and SocketCodeTable::portCodeCount().

Referenced by conflictsWithDestinationEncodings(), and conflictsWithSourceEncodings().

Here is the call graph for this function:

conflictsWithSourceEncodings()

bool BEMTester::conflictsWithSourceEncodings ( const SourceField &  field, unsigned int  encoding, unsigned int  width, int  offset  )

staticprivate

Checks that the given encoding and others in the field can be distinguished from each other.

Parameters

field	The source field.
encoding	The encoding.
width	The width of the encoding where the encoding value is right aligned.
offset	The relative position of the encoding to the field's LSB. Positive shifts the encoding towards MSB and vice versa.

Returns

True if the encoding can not be distinguished from another encoding.

Definition at line 488 of file BEMTester.cc.

                {
    unsigned truncatedEncoding;
    unsigned truncatedWidth;
    unsigned truncatedOffset;
 
    for (int i = 0; i < field.socketEncodingCount(); i++) {
        const SocketEncoding& socketEnc = field.socketEncoding(i);
 
        bool socketIDOverlap = fieldsOverlap(
            socketEnc.socketIDWidth(), socketEnc.socketIDPosition(), width,
            offset);
        std::tie(truncatedEncoding, truncatedWidth, truncatedOffset) =
            splitEncodingTo(socketEnc, encoding, width, offset);
        bool socketIDMatch = MathTools::bitFieldsEquals(
            socketEnc.encoding(), truncatedOffset, truncatedEncoding, 0,
            truncatedWidth);
 
        const SocketCodeTable& scTable = socketEnc.socketCodes();
        // Get the part that overlaps with port codes.
        std::tie(truncatedEncoding, truncatedWidth, truncatedOffset) =
            splitEncoding(
                encoding, width, scTable.width(),
                offset - socketEnc.socketCodePosition());
        bool socketCodeOverlap = truncatedWidth > 0;
        bool socketCodeMatch = conflictsWithSocketTableEncodings(
            scTable, truncatedEncoding, truncatedWidth, truncatedOffset);
 
        if (socketIDOverlap) {
            if (socketCodeMatch && socketIDMatch && socketCodeMatch) {
                return true;
            } else if (!socketCodeOverlap && socketIDMatch) {
                return true;
            }
        } else if (socketCodeOverlap && socketCodeMatch) {
            return true;
        }
    }
 
    // check against simm
    if (field.hasImmediateEncoding()) {
        const ImmediateEncoding& simmEnc = field.immediateEncoding();
        std::tie(truncatedEncoding, truncatedWidth, truncatedOffset) =
            splitEncoding(
                encoding, width, simmEnc.encodingWidth(),
                offset - simmEnc.encodingPosition());
 
        if (MathTools::bitFieldsEquals(
                simmEnc.encoding(), truncatedOffset, truncatedEncoding, 0,
                truncatedWidth)) {
            return true;
        }
    }
 
    return false;
}

References MathTools::bitFieldsEquals(), conflictsWithSocketTableEncodings(), Encoding::encoding(), ImmediateEncoding::encodingPosition(), ImmediateEncoding::encodingWidth(), fieldsOverlap(), SourceField::hasImmediateEncoding(), SourceField::immediateEncoding(), SocketEncoding::socketCodePosition(), SocketEncoding::socketCodes(), SlotField::socketEncoding(), SlotField::socketEncodingCount(), SocketEncoding::socketIDPosition(), SocketEncoding::socketIDWidth(), splitEncoding(), splitEncodingTo(), and SocketCodeTable::width().

Referenced by canAddComponentPriorityEncoding().

Here is the call graph for this function:

fieldsOverlap() [1/2]

bool BEMTester::fieldsOverlap ( const InstructionField &  with, unsigned int  toFieldWidth, int  toFieldPos  )

staticprivate

Checks if a field relatively at position to an instruction field do overlap.

*       |<- instruction field ->|
*    |<-- width -->|<---- pos --|
* ------------------------------0
* => true
* 

Parameters

with
toFieldWidth
toFieldPos	The relative position of the field to the instruction field.

Returns

True if the fields do overlap. Otherwise false.

Definition at line 382 of file BEMTester.cc.

                                                                             {
    return fieldsOverlap(
        with.width(), with.bitPosition(), toFieldWidth, toFieldPos);
}

References InstructionField::bitPosition(), fieldsOverlap(), and InstructionField::width().

Referenced by canAddComponentPriorityEncoding(), conflictsWithDestinationEncodings(), conflictsWithSocketTableEncodings(), conflictsWithSourceEncodings(), and fieldsOverlap().

Here is the call graph for this function:

fieldsOverlap() [2/2]

bool BEMTester::fieldsOverlap ( unsigned  width1, int  pos1, unsigned  width2, int  pos2  )

staticprivate

Checks if the given fields overlaps

*                              |- pos1 -->|
*                  |<------ width1 ------>|
*       |<- width2 ->|         |
*                    |<- pos2 -|
*                        <- +  0
*                ->| |<- overlaps => true
* 

Parameters

width1	The width of the 1st field.
pos1	The position of the 1st field.
width2	The width of the 2nd field.
pos2	The position of the 2nd field.

Returns

True if there is overlap. Otherwise return false.

Definition at line 407 of file BEMTester.cc.

                                                          {
    // positive = overlapping width, negative = separation width
    return (std::min(
                pos1 + static_cast<int>(width1),
                pos2 + static_cast<int>(width2)) -
            std::max(pos1, pos2)) > 0;
}

splitEncoding()

std::tuple< unsigned, unsigned, int > BEMTester::splitEncoding ( unsigned  encoding, unsigned  encodingWidth, unsigned  targetWidth, int  offsetToTarget  )

staticprivate

Splits encoding to the target field.

the splitted encoding is returned as tuple where the 1st item is encoding bits leaving out non-overlapping bits, the 2nd item is resulted width (width of overlap) and the 3rd item is position of the resulted encoding within the target field.

*    msb                  lsb
*     |<- encoding width ->|
*     |00001010110100100100|
*                          |<-- offset (>0) --|
*                  |<-  target width        ->|
*----------------------------------------------
* result encoding: |0100100|
*    result width: |<----->|<-- offset (>0) --|
* 

Definition at line 677 of file BEMTester.cc.

                        {
    long int resultWidth =
        std::min(
            static_cast<int>(targetWidth),
            offsetToTarget + static_cast<int>(encodingWidth)) -
        std::max(0, offsetToTarget);
 
    if (offsetToTarget > static_cast<int>(targetWidth) || resultWidth <= 0) {
        return std::make_tuple(0, 0, 0);
    }
 
    unsigned resultEncoding = encoding;
    int resultOffset = offsetToTarget;
 
    if (offsetToTarget < 0) {
        assert(-offsetToTarget < 32 && "Invalid shift amount.");
        resultEncoding = resultEncoding >> -offsetToTarget;
        resultOffset = 0;
    }
    assert(resultWidth < 32 && "Invalid shift amount.");
    unsigned mask = ~(~(0u) << resultWidth);
    resultEncoding &= mask;
    return std::make_tuple(resultEncoding, resultWidth, resultOffset);
}

References assert.

Referenced by canAddComponentPriorityEncoding(), conflictsWithDestinationEncodings(), conflictsWithSourceEncodings(), and splitEncodingTo().

splitEncodingTo()

std::tuple< unsigned, unsigned, int > BEMTester::splitEncodingTo ( const SocketEncoding &  socketEncoding, unsigned  encoding, unsigned  encodingWidth, int  offsetToTarget  )

staticprivate

Splits the given encoding that overlaps with the SocketEncoding.

Returns tuple where the 1st item is encoding bits leaving out non-overlapping bits, the 2nd item is resulted width (width of the overlap) and the 3rd item is position of the resulted encoding within the SocketEncoding.

Definition at line 713 of file BEMTester.cc.

                                                {
    return splitEncoding(
        encoding, encodingWidth, socketEncoding.socketIDWidth(),
        offsetToTarget - socketEncoding.socketIDPosition());
}

References SocketEncoding::socketIDPosition(), SocketEncoding::socketIDWidth(), and splitEncoding().

Referenced by conflictsWithDestinationEncodings(), and conflictsWithSourceEncodings().

Here is the call graph for this function:

---

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

• BEMTester.hh
• BEMTester.cc