FlowStatistics.cci

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#include <senf/Utils/senflikely.hh>

#define prefix_ inline
///////////////////////////////cci.p///////////////////////////////////////


///////////////////////////////////////////////////////////////////////////
// senf::SequenceNumberStatistics

prefix_ senf::SequenceNumberStatistics::SequenceNumberStatistics(std::uint8_t bits, std::int32_t maxLate)
    : DifferenceSigned(bits),
      maxLate_(maxLate)
{
    reset();
}

prefix_ void senf::SequenceNumberStatistics::reset()
{
    clear();
    last_ = 0;
    goodTotal = 0;
    goodBytesTotal = 0;
    firstUpdateAfterReset_ = true;
}

prefix_ void senf::SequenceNumberStatistics::clear()
{
    goodTotal += good;
    goodBytesTotal += goodBytes;
    good = goodBytes = duplicate = late = lost = lostLate = lateMax = 0;
    resyncs = 0;
}

prefix_ std::int32_t senf::SequenceNumberStatistics::maxLate()
    const
{
    return maxLate_;
}

prefix_ void senf::SequenceNumberStatistics::countGood(std::uint32_t payloadSize)
{
    good++;
    goodBytes += payloadSize;
}

prefix_ bool senf::SequenceNumberStatistics::update(std::uint32_t seqNo, std::uint32_t payloadSize)
{
    if (SENF_UNLIKELY(firstUpdateAfterReset_)) {
        firstUpdateAfterReset_ = false;
        countGood(payloadSize);
        last_ = seqNo;
        return true;
    }

    auto diff (difference(seqNo, last_));

    if (SENF_LIKELY(diff == 1)) {
        // no loss
        countGood(payloadSize);
        last_ = seqNo;
        return true;
    }
    else if (diff == 0) {
        // duplicate
        duplicate++;
    }
    else if (diff < 0) {
        // late frame(s) => reordering
        if (diff <= -maxLate_) {
            // resync to next expected SeqNo
            resyncs++;
            countGood(payloadSize);
            last_ = seqNo;
            return true;
        } else {
            // we are tolerant to reordering here. So, let's account for it, ...
            late++;
            lateMax = std::max(lateMax, std::uint32_t(-diff));
            if (SENF_LIKELY(lost > 0)) {
               // we counted this 'late' frame as lost before, so let's reduce the lost count here
               lost--;
               // count 'recovered' frames
               lostLate++;
               countGood(payloadSize);
            }
            // ... but not suggest to drop the frame
            return true;
        }
    } else {
        // frame loss
        lost += diff-1;
        countGood(payloadSize);
        last_ = seqNo;
        return true;
    }

    // essentially, we only indidate 'duplicates' to be dropped
    return false;
}

prefix_ void senf::SequenceNumberStatistics::dump(std::ostream & os, senf::ClockService::clock_type const & period)
    const
{
    os << "good " << good << ", goodBytes " << goodBytes;
    if (period) {
        os << ", good/s " << ((std::uint64_t(good) * 1000) / senf::ClockService::in_milliseconds(period));
        os << ", goodBytes/s " << ((std::uint64_t(goodBytes) * 1000) / senf::ClockService::in_milliseconds(period));
    }
    os << ", duplicate " << duplicate << ", late " << late << ", lost " << lost;
    os << ", resyncs " << resyncs;
}


///////////////////////////////////////////////////////////////////////////
// senf::TimestampStatistics

prefix_ senf::TimestampStatistics::TimestampStatistics(std::uint8_t bits)
    : DifferenceSigned(bits)
{
    reset();
}

prefix_ void senf::TimestampStatistics::reset()
{
    clear();
    lastPD_ = 0;
    firstUpdateAfterReset_ = true;
}

prefix_ void senf::TimestampStatistics::clear()
{
    delay.clear();
    pdv.clear();
}


prefix_ void senf::TimestampStatistics::update(std::uint32_t txTStamp, std::uint32_t rxTStamp, bool updateDelay)
{
    auto diff (difference(rxTStamp, txTStamp));

    // first packet seen => establish the typical delay
    if (SENF_UNLIKELY(firstUpdateAfterReset_)) {
        firstUpdateAfterReset_ = false;
        lastPD_ = diff;
    }

    pdv.accumulate(unsigned(abs(diff - lastPD_)));
    lastPD_ = diff;

    if (updateDelay) {
        delay.accumulate(diff);
    }
}


///////////////////////////////cci.e///////////////////////////////////////
#undef prefix_