bin/perfdhcp/stats_mgr.h

Go to the documentation of this file.

// Copyright (C) 2012-2021 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef STATS_MGR_H
#define STATS_MGR_H

#include <dhcp/pkt.h>
#include <exceptions/exceptions.h>
#include <perfdhcp/command_options.h>

#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/global_fun.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include <iostream>
#include <map>
#include <queue>


namespace isc {
namespace perfdhcp {

enum class ExchangeType {
    DO,  
    RA,  
    RNA, 
    SA,  
    RR,  
    RN,  
    RL   
};

int dhcpVersion(ExchangeType const exchange_type);

std::ostream& operator<<(std::ostream& os, ExchangeType xchg_type);

class CustomCounter {
public:
    CustomCounter(const std::string& name) :
        counter_(0),
        name_(name) { };

    const CustomCounter& operator++() {
        ++counter_;
        return (*this);
    }

    const CustomCounter& operator++(int) {
        CustomCounter& this_counter(*this);
        operator++();
        return (this_counter);
    }

    const CustomCounter& operator+=(int val) {
        counter_ += val;
        return (*this);
    }

    uint64_t getValue() const { return(counter_); }

    const std::string& getName() const { return(name_); }

private:
    CustomCounter() { };

    uint64_t counter_;  
    std::string name_;  
};

typedef typename boost::shared_ptr<CustomCounter> CustomCounterPtr;

typedef typename std::map<std::string, CustomCounterPtr> CustomCountersMap;

typedef typename CustomCountersMap::const_iterator CustomCountersMapIterator;


class ExchangeStats {
public:

    static uint32_t hashTransid(const dhcp::PktPtr& packet) {
        if (!packet) {
            isc_throw(BadValue, "Packet is null");
        }
        return(packet->getTransid() & 1023);
    }

    typedef boost::multi_index_container<
        // Container holds PktPtr objects.
        dhcp::PktPtr,
        // List container indexes.
        boost::multi_index::indexed_by<
            // Sequenced index provides the way to use this container
            // in the same way as std::list.
            boost::multi_index::sequenced<>,
            // The other index keeps products of transaction id.
            // Elements with the same hash value are grouped together
            // into buckets and transactions are ordered from the
            // oldest to latest within a bucket.
            boost::multi_index::ordered_non_unique<
                // Specify hash function to get the product of
                // transaction id. This product is obtained by calling
                // hashTransid() function.
                boost::multi_index::global_fun<
                    // Hashing function takes PktPtr as argument.
                    const dhcp::PktPtr&,
                    // ... and returns uint32 value.
                    uint32_t,
                    // ... and here is a reference to it.
                    &ExchangeStats::hashTransid
                    >
                >
            >
        > PktList;

    typedef typename PktList::iterator PktListIterator;
    typedef typename PktList::template nth_index<1>::type
    PktListTransidHashIndex;
    typedef typename PktListTransidHashIndex::const_iterator
    PktListTransidHashIterator;
    typedef typename std::queue<PktListTransidHashIterator>
    PktListRemovalQueue;

    ExchangeStats(const ExchangeType xchg_type,
                  const double drop_time,
                  const bool archive_enabled,
                  const boost::posix_time::ptime boot_time);

    void appendSent(const dhcp::PktPtr& packet) {
        if (!packet) {
            isc_throw(BadValue, "Packet is null");
        }
        static_cast<void>(sent_packets_.template get<0>().push_back(packet));
        ++sent_packets_num_;
    }

    void appendRcvd(const dhcp::PktPtr& packet) {
        if (!packet) {
            isc_throw(BadValue, "Packet is null");
        }
        static_cast<void>(rcvd_packets_.push_back(packet));
    }

    void updateDelays(const dhcp::PktPtr& sent_packet,
                      const dhcp::PktPtr& rcvd_packet);

    dhcp::PktPtr matchPackets(const dhcp::PktPtr& rcvd_packet);

    double getMinDelay() const { return(min_delay_); }

    double getMaxDelay() const { return(max_delay_); }

    double getAvgDelay() const {
        if (rcvd_packets_num_  == 0) {
            isc_throw(InvalidOperation, "no packets received");
        }
        return(sum_delay_ / rcvd_packets_num_);
    }

    double getStdDevDelay() const {
        if (rcvd_packets_num_ == 0) {
            isc_throw(InvalidOperation, "no packets received");
        }
        return(sqrt(sum_delay_squared_ / rcvd_packets_num_ -
                    getAvgDelay() * getAvgDelay()));
    }

    uint64_t getOrphans() const { return(orphans_); }

    uint64_t getCollectedNum() const { return(collected_); }

    double getAvgUnorderedLookupSetSize() const {
        if (unordered_lookups_ == 0) {
            isc_throw(InvalidOperation, "no unordered lookups");
        }
        return(static_cast<double>(unordered_lookup_size_sum_) /
               static_cast<double>(unordered_lookups_));
    }

    uint64_t getUnorderedLookups() const { return(unordered_lookups_); }

    uint64_t getOrderedLookups() const { return(ordered_lookups_); }

    uint64_t getSentPacketsNum() const { return(sent_packets_num_); }

    uint64_t getRcvdPacketsNum() const { return(rcvd_packets_num_); }

    uint64_t getDroppedPacketsNum() const {
        uint64_t drops = 0;
        if (getSentPacketsNum() > getRcvdPacketsNum()) {
            drops = getSentPacketsNum() - getRcvdPacketsNum();
        }
        return(drops);
    }

    uint64_t getRejLeasesNum() const { return(rejected_leases_num_); }

    uint64_t getNonUniqueAddrNum() const { return(non_unique_addr_num_); }

    void updateRejLeases() { ++rejected_leases_num_; }

    void updateNonUniqueAddr() { ++non_unique_addr_num_; }

    void printMainStats() const {
        using namespace std;
        auto sent = getSentPacketsNum();
        auto drops = getDroppedPacketsNum();
        double drops_ratio = 100.0 * static_cast<double>(drops) / static_cast<double>(sent);

        cout << "sent packets: " << sent << endl
             << "received packets: " << getRcvdPacketsNum() << endl
             << "drops: " << drops << endl
             << "drops ratio: " << drops_ratio << " %" << endl
             << "orphans: " << getOrphans() << endl
             << "rejected leases: " << getRejLeasesNum() << endl
             << "non unique addresses: " << getNonUniqueAddrNum() << endl;
    }

    void printRTTStats() const {
        using namespace std;
        try {
            cout << fixed << setprecision(3)
                 << "min delay: " << getMinDelay() * 1e3 << " ms" << endl
                 << "avg delay: " << getAvgDelay() * 1e3 << " ms" << endl
                 << "max delay: " << getMaxDelay() * 1e3 << " ms" << endl
                 << "std deviation: " << getStdDevDelay() * 1e3 << " ms"
                 << endl
                 << "collected packets: " << getCollectedNum() << endl;
        } catch (const Exception&) {
            // repeated output for easier automated parsing
            cout << "min delay: n/a" << endl
                 << "avg delay: n/a" << endl
                 << "max delay: n/a" << endl
                 << "std deviation: n/a" << endl
                 << "collected packets: 0" << endl;
        }
    }

    void printTimestamps();

    std::tuple<PktListIterator, PktListIterator> getSentPackets() {
        return(std::make_tuple(sent_packets_.begin(), sent_packets_.end()));
    }

    std::string receivedLeases() const;

    void printLeases() const;

    static int malformed_pkts_;

// Private stuff of ExchangeStats class
private:

    ExchangeStats();

    PktListIterator eraseSent(const PktListIterator it) {
        if (archive_enabled_) {
            // We don't want to keep list of all sent packets
            // because it will affect packet lookup performance.
            // If packet is matched with received packet we
            // move it to list of archived packets. List of
            // archived packets may be used for diagnostics
            // when test is completed.
            static_cast<void>(archived_packets_.push_back(*it));
        }
        // get<0>() template returns sequential index to
        // container.
        return(sent_packets_.template get<0>().erase(it));
    }

    ExchangeType xchg_type_;             
    PktList sent_packets_;               

    PktListIterator next_sent_;

    PktList rcvd_packets_;         

    PktList archived_packets_;

    bool archive_enabled_;

    double drop_time_;

    double min_delay_;             
    double max_delay_;             
    double sum_delay_;             
    double sum_delay_squared_;     

    uint64_t orphans_;   

    uint64_t collected_; 

    uint64_t unordered_lookup_size_sum_;

    uint64_t unordered_lookups_;   
    uint64_t ordered_lookups_;     

    uint64_t sent_packets_num_;    
    uint64_t rcvd_packets_num_;    

    uint64_t non_unique_addr_num_; 
    uint64_t rejected_leases_num_; 
    boost::posix_time::ptime boot_time_; 
};

typedef boost::shared_ptr<ExchangeStats> ExchangeStatsPtr;

typedef typename std::map<ExchangeType, ExchangeStatsPtr> ExchangesMap;

typedef typename ExchangesMap::const_iterator ExchangesMapIterator;


class StatsMgr : public boost::noncopyable {
public:
    StatsMgr(CommandOptions& options);

    void addExchangeStats(const ExchangeType xchg_type,
                          const double drop_time = -1) {
        if (exchanges_.find(xchg_type) != exchanges_.end()) {
            isc_throw(BadValue, "Exchange of specified type already added.");
        }
        exchanges_[xchg_type] =
            ExchangeStatsPtr(new ExchangeStats(xchg_type,
                                               drop_time,
                                               archive_enabled_,
                                               boot_time_));
    }

    bool hasExchangeStats(const ExchangeType xchg_type) const {
        return (exchanges_.find(xchg_type) != exchanges_.end());
    }

    void addCustomCounter(const std::string& short_name,
                          const std::string& long_name) {
        if (custom_counters_.find(short_name) != custom_counters_.end()) {
            isc_throw(BadValue,
                      "Custom counter " << short_name << " already added.");
        }
        custom_counters_[short_name] =
            CustomCounterPtr(new CustomCounter(long_name));
    }

    // \return true, if packet drops occurred.
    bool droppedPackets() const {
        for (ExchangesMapIterator it = exchanges_.begin();
             it != exchanges_.end();
             ++it) {
            if (it->second->getDroppedPacketsNum() > 0) {
                return (true);
            }
        }
        return (false);
    }

    CustomCounterPtr getCounter(const std::string& counter_key) {
        CustomCountersMapIterator it = custom_counters_.find(counter_key);
        if (it == custom_counters_.end()) {
            isc_throw(BadValue,
                      "Custom counter " << counter_key << "does not exist");
        }
        return(it->second);
    }

    const CustomCounter& incrementCounter(const std::string& counter_key,
                                          const uint64_t value = 1) {
        CustomCounterPtr counter = getCounter(counter_key);
        *counter += value;
        return (*counter);
    }

    void passSentPacket(const ExchangeType xchg_type,
                        const dhcp::PktPtr& packet) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        xchg_stats->appendSent(packet);
    }

    dhcp::PktPtr
    passRcvdPacket(const ExchangeType xchg_type,
                   const dhcp::PktPtr& packet) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        dhcp::PktPtr sent_packet = xchg_stats->matchPackets(packet);

        if (sent_packet) {
            xchg_stats->updateDelays(sent_packet, packet);
            if (archive_enabled_) {
                xchg_stats->appendRcvd(packet);
            }
        }
        return(sent_packet);
    }

    double getMinDelay(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getMinDelay());
    }

    double getMaxDelay(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getMaxDelay());
    }

    double getAvgDelay(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getAvgDelay());
    }

    double getStdDevDelay(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getStdDevDelay());
    }

    uint64_t getOrphans(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getOrphans());
    }

    double getAvgUnorderedLookupSetSize(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getAvgUnorderedLookupSetSize());
    }

    uint64_t getUnorderedLookups(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getUnorderedLookups());
    }

    uint64_t getOrderedLookups(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getOrderedLookups());
    }

    uint64_t getSentPacketsNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getSentPacketsNum());
    }

    uint64_t getRcvdPacketsNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getRcvdPacketsNum());
    }

    uint64_t getDroppedPacketsNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getDroppedPacketsNum());
    }

    uint64_t getCollectedNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getCollectedNum());
    }

    uint64_t getRejLeasesNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getRejLeasesNum());
    }

    void updateRejLeases(const ExchangeType xchg_type) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        xchg_stats->updateRejLeases();
    }

    void updateNonUniqueAddrNum(const ExchangeType xchg_type) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        xchg_stats->updateNonUniqueAddr();
    }

    uint64_t getNonUniqueAddrNum(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        return(xchg_stats->getNonUniqueAddrNum());
    }

    boost::posix_time::time_period getTestPeriod() const {
        using namespace boost::posix_time;
        time_period test_period(boot_time_,
                                microsec_clock::universal_time());
        return test_period;
    }

    void printStats() const {
        if (exchanges_.empty()) {
            isc_throw(isc::InvalidOperation,
                      "no exchange type added for tracking");
        }
        for (ExchangesMapIterator it = exchanges_.begin();
             it != exchanges_.end();
             ++it) {
            ExchangeStatsPtr xchg_stats = it->second;
            std::cout << "***Statistics for: " << it->first
                      << "***" << std::endl;
            xchg_stats->printMainStats();
            std::cout << std::endl;
            xchg_stats->printRTTStats();
            std::cout << std::endl;
        }
    }

    void
    printIntermediateStats(bool clean_report, std::string clean_sep) const {
        std::ostringstream stream_sent;
        std::ostringstream stream_rcvd;
        std::ostringstream stream_drops;
        std::ostringstream stream_reject;
        std::string sep("");
        for (ExchangesMapIterator it = exchanges_.begin();
             it != exchanges_.end(); ++it) {

            if (it != exchanges_.begin()) {
                if (clean_report) {
                    sep = clean_sep;
                } else {
                    sep = "/";
                }
            }
            stream_sent << sep << it->second->getSentPacketsNum();
            stream_rcvd << sep << it->second->getRcvdPacketsNum();
            stream_drops << sep << it->second->getDroppedPacketsNum();
            stream_reject << sep << it->second->getRejLeasesNum();
        }

        if (clean_report) {
        std::cout << stream_sent.str()
                  << clean_sep << stream_rcvd.str()
                  << clean_sep << stream_drops.str()
                  << clean_sep << stream_reject.str()
                  << std::endl;

        } else {
        std::cout << "sent: " << stream_sent.str()
                  << "; received: " << stream_rcvd.str()
                  << "; drops: " << stream_drops.str()
                  << "; rejected: " << stream_reject.str()
                  << std::endl;
        }
    }

    void printTimestamps() const {
        if (exchanges_.empty()) {
            isc_throw(isc::InvalidOperation,
                      "no exchange type added for tracking");
        }
        for (ExchangesMapIterator it = exchanges_.begin();
             it != exchanges_.end();
             ++it) {
            ExchangeStatsPtr xchg_stats = it->second;
            std::cout << "***Timestamps for packets: "
                      << it->first
                      << "***" << std::endl;
            xchg_stats->printTimestamps();
            std::cout << std::endl;
        }
    }

    void printLeases() const;

    void printCustomCounters() const {
        if (custom_counters_.empty()) {
            isc_throw(isc::InvalidOperation, "no custom counters specified");
        }
        for (CustomCountersMapIterator it = custom_counters_.begin();
             it != custom_counters_.end();
             ++it) {
            CustomCounterPtr counter = it->second;
            std::cout << counter->getName() << ": " << counter->getValue()
                      << std::endl;
        }
    }

    std::tuple<typename ExchangeStats::PktListIterator, typename ExchangeStats::PktListIterator> getSentPackets(const ExchangeType xchg_type) const {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        std::tuple<typename ExchangeStats::PktListIterator, typename ExchangeStats::PktListIterator> sent_packets_its = xchg_stats->getSentPackets();
        return(sent_packets_its);
    }

private:

    ExchangeStatsPtr getExchangeStats(const ExchangeType xchg_type) const {
        ExchangesMapIterator it = exchanges_.find(xchg_type);
        if (it == exchanges_.end()) {
            isc_throw(BadValue, "Packets exchange not specified");
        }
        ExchangeStatsPtr xchg_stats = it->second;
        return(xchg_stats);
    }

    ExchangesMap exchanges_;            
    CustomCountersMap custom_counters_; 

    bool archive_enabled_;

    boost::posix_time::ptime boot_time_; 
};

typedef boost::shared_ptr<StatsMgr> StatsMgrPtr;


} // namespace perfdhcp
} // namespace isc

#endif // STATS_MGR_H