bin/perfdhcp/stats_mgr.h

Go to the documentation of this file.

// Copyright (C) 2012-2016 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/pkt4.h>
#include <dhcp/pkt6.h>
#include <exceptions/exceptions.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 {
 
template <class T = dhcp::Pkt4>
class StatsMgr : public boost::noncopyable {
public:
 
    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;
 
    enum ExchangeType {
        XCHG_DO,  
        XCHG_RA,  
        XCHG_RNA, 
        XCHG_SA,  
        XCHG_RR,  
        XCHG_RN,  
        XCHG_RL   
    };
 
    class ExchangeStats {
    public:
 
        static uint32_t hashTransid(const boost::shared_ptr<T>& packet) {
            if (!packet) {
                isc_throw(BadValue, "Packet is null");
            }
            return(packet->getTransid() & 1023);
        }
 
        typedef boost::multi_index_container<
            // Container holds shared_ptr<Pkt4> or shared_ptr<Pkt6> objects.
            boost::shared_ptr<T>,
            // 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 shared_ptr<Pkt4> or
                        // shared_ptr<Pkt6> as argument.
                        const boost::shared_ptr<T>&,
                        // ... 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)
            : xchg_type_(xchg_type),
              sent_packets_(),
              rcvd_packets_(),
              archived_packets_(),
              archive_enabled_(archive_enabled),
              drop_time_(drop_time),
              min_delay_(std::numeric_limits<double>::max()),
              max_delay_(0.),
              sum_delay_(0.),
              sum_delay_squared_(0.),
              orphans_(0),
              collected_(0),
              unordered_lookup_size_sum_(0),
              unordered_lookups_(0),
              ordered_lookups_(0),
              sent_packets_num_(0),
              rcvd_packets_num_(0),
              boot_time_(boot_time)
        {
            next_sent_ = sent_packets_.begin();
        }
 
        void appendSent(const boost::shared_ptr<T>& packet) {
            if (!packet) {
                isc_throw(BadValue, "Packet is null");
            }
            ++sent_packets_num_;
            sent_packets_.template get<0>().push_back(packet);
        }
 
        void appendRcvd(const boost::shared_ptr<T>& packet) {
            if (!packet) {
                isc_throw(BadValue, "Packet is null");
            }
            rcvd_packets_.push_back(packet);
        }
 
        void updateDelays(const boost::shared_ptr<T>& sent_packet,
                          const boost::shared_ptr<T>& rcvd_packet) {
            if (!sent_packet) {
                isc_throw(BadValue, "Sent packet is null");
            }
            if (!rcvd_packet) {
                isc_throw(BadValue, "Received packet is null");
            }
 
            boost::posix_time::ptime sent_time = sent_packet->getTimestamp();
            boost::posix_time::ptime rcvd_time = rcvd_packet->getTimestamp();
 
            if (sent_time.is_not_a_date_time() ||
                rcvd_time.is_not_a_date_time()) {
                isc_throw(Unexpected,
                          "Timestamp must be set for sent and "
                          "received packet to measure RTT");
            }
            boost::posix_time::time_period period(sent_time, rcvd_time);
            // We don't bother calculating deltas in nanoseconds. It is much
            // more convenient to use seconds instead because we are going to
            // sum them up.
            double delta =
                static_cast<double>(period.length().total_nanoseconds()) / 1e9;
 
            if (delta < 0) {
                isc_throw(Unexpected, "Sent packet's timestamp must not be "
                          "greater than received packet's timestamp");
            }
 
            // Record the minimum delay between sent and received packets.
            if (delta < min_delay_) {
                min_delay_ = delta;
            }
            // Record the maximum delay between sent and received packets.
            if (delta > max_delay_) {
                max_delay_ = delta;
            }
            // Update delay sum and square sum. That will be used to calculate
            // mean delays.
            sum_delay_ += delta;
            sum_delay_squared_ += delta * delta;
        }
 
        boost::shared_ptr<T>
        matchPackets(const boost::shared_ptr<T>& rcvd_packet) {
            using namespace boost::posix_time;
 
            if (!rcvd_packet) {
                isc_throw(BadValue, "Received packet is null");
            }
 
            if (sent_packets_.size() == 0) {
                // List of sent packets is empty so there is no sense
                // to continue looking fo the packet. It also means
                // that the received packet we got has no corresponding
                // sent packet so orphans counter has to be updated.
                ++orphans_;
                return(boost::shared_ptr<T>());
            } else if (next_sent_ == sent_packets_.end()) {
                // Even if there are still many unmatched packets on the
                // list we might hit the end of it because of unordered
                // lookups. The next logical step is to reset iterator.
                next_sent_ = sent_packets_.begin();
            }
 
            // With this variable we will be signalling success or failure
            // to find the packet.
            bool packet_found = false;
            // Most likely responses are sent from the server in the same
            // order as client's requests to the server. We are caching
            // next sent packet and first try to match it with the next
            // incoming packet. We are successful if there is no
            // packet drop or out of order packets sent. This is actually
            // the fastest way to look for packets.
            if ((*next_sent_)->getTransid() == rcvd_packet->getTransid()) {
                ++ordered_lookups_;
                packet_found = true;
            } else {
                // If we are here, it means that we were unable to match the
                // next incoming packet with next sent packet so we need to
                // take a little more expensive approach to look packets using
                // alternative index (transaction id & 1023).
                PktListTransidHashIndex& idx = sent_packets_.template get<1>();
                // Packets are grouped using transaction id masked with value
                // of 1023. For instance, packets with transaction id equal to
                // 1, 1024 ... will belong to the same group (a.k.a. bucket).
                // When using alternative index we don't find the packet but
                // bucket of packets and we need to iterate through the bucket
                // to find the one that has desired transaction id.
                std::pair<PktListTransidHashIterator,PktListTransidHashIterator> p =
                    idx.equal_range(hashTransid(rcvd_packet));
                // We want to keep statistics of unordered lookups to make
                // sure that there is a right balance between number of
                // unordered lookups and ordered lookups. If number of unordered
                // lookups is high it may mean that many packets are lost or
                // sent out of order.
                ++unordered_lookups_;
                // We also want to keep the mean value of the bucket. The lower
                // bucket size the better. If bucket sizes appear to big we
                // might want to increase number of buckets.
                unordered_lookup_size_sum_ += std::distance(p.first, p.second);
                bool non_expired_found = false;
                // Removal can be done only after the loop
                PktListRemovalQueue to_remove;
                for (PktListTransidHashIterator it = p.first; it != p.second;
                     ++it) {
                    // If transaction id is matching, we found the original
                    // packet sent to the server. Therefore, we reset the
                    // 'next sent' pointer to point to this location. We
                    // also indicate that the matching packet is found.
                    // Even though the packet has been found, we continue
                    // iterating over the bucket to remove all those packets
                    // that are timed out.
                    if (!packet_found && ((*it)->getTransid() == rcvd_packet->getTransid())) {
                        packet_found = true;
                        next_sent_ = sent_packets_.template project<0>(it);
                    }
 
                    if (!non_expired_found) {
                        // Check if the packet should be removed due to timeout.
                        // This includes the packet matching the received one.
                        ptime now = microsec_clock::universal_time();
                        ptime packet_time = (*it)->getTimestamp();
                        time_period packet_period(packet_time, now);
                        if (!packet_period.is_null()) {
                            double period_fractional =
                                packet_period.length().total_seconds() +
                                (static_cast<double>(packet_period.length().fractional_seconds())
                                 / packet_period.length().ticks_per_second());
                            if (drop_time_ > 0 && (period_fractional > drop_time_)) {
                                // Push the iterator on the removal queue.
                                to_remove.push(it);
 
                            } else {
                                // We found first non-expired transaction. All other
                                // transactions within this bucket are considered
                                // non-expired because packets are held in the
                                // order of addition within the bucket.
                                non_expired_found = true;
                            }
                        }
                    }
 
                    // If we found the packet and all expired transactions,
                    // there is nothing more to do.
                    if (non_expired_found && packet_found) {
                        break;
                    }
                }
 
                // Deal with the removal queue.
                while (!to_remove.empty()) {
                    PktListTransidHashIterator it = to_remove.front();
                    to_remove.pop();
                    // If timed out packet is not the one matching server response,
                    // we simply remove it and keep the pointer to the 'next sent'
                    // packet as it was. If the timed out packet appears to be the
                    // one that is matching the server response, we still want to
                    // remove it, but we need to update the 'next sent' pointer to
                    // point to a valid location.
                    if (sent_packets_.template project<0>(it) != next_sent_) {
                        eraseSent(sent_packets_.template project<0>(it));
                    } else {
                        next_sent_ = eraseSent(sent_packets_.template project<0>(it));
                        // We removed the matching packet because of the timeout. It
                        // means that there is no match anymore.
                        packet_found = false;
                    }
                    ++collected_;
                }
            }
 
            if (!packet_found) {
                // If we are here, it means that both ordered lookup and
                // unordered lookup failed. Searched packet is not on the list.
                ++orphans_;
                return(boost::shared_ptr<T>());
            }
 
            // Packet is matched so we count it. We don't count unmatched packets
            // as they are counted as orphans with a separate counter.
            ++rcvd_packets_num_;
            boost::shared_ptr<T> sent_packet(*next_sent_);
            // If packet was found, we assume it will be never searched
            // again. We want to delete this packet from the list to
            // improve performance of future searches.
            next_sent_ = eraseSent(next_sent_);
            return(sent_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);
        }
 
        void printMainStats() const {
            using namespace std;
            cout << "sent packets: " << getSentPacketsNum() << endl
                 << "received packets: " << getRcvdPacketsNum() << endl
                 << "drops: " << getDroppedPacketsNum() << endl;
            //                 << "orphans: " << getOrphans() << 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&) {
                cout << "Delay summary unavailable! No packets received." << endl;
            }
        }
 
        void printTimestamps() {
            // If archive mode is disabled there is no sense to proceed
            // because we don't have packets and their timestamps.
            if (!archive_enabled_) {
                isc_throw(isc::InvalidOperation,
                          "packets archive mode is disabled");
            }
            if (rcvd_packets_num_ == 0) {
                std::cout << "Unavailable! No packets received." << std::endl;
            }
            // We will be using boost::posix_time extensively here
            using namespace boost::posix_time;
 
            // Iterate through all received packets.
            for (PktListIterator it = rcvd_packets_.begin();
                 it != rcvd_packets_.end();
                 ++it) {
                boost::shared_ptr<T> rcvd_packet = *it;
                PktListTransidHashIndex& idx =
                    archived_packets_.template get<1>();
                std::pair<PktListTransidHashIterator,
                          PktListTransidHashIterator> p =
                    idx.equal_range(hashTransid(rcvd_packet));
                for (PktListTransidHashIterator it_archived = p.first;
                     it_archived != p.second;
                     ++it_archived) {
                    if ((*it_archived)->getTransid() ==
                        rcvd_packet->getTransid()) {
                        boost::shared_ptr<T> sent_packet = *it_archived;
                        // Get sent and received packet times.
                        ptime sent_time = sent_packet->getTimestamp();
                        ptime rcvd_time = rcvd_packet->getTimestamp();
                        // All sent and received packets should have timestamps
                        // set but if there is a bug somewhere and packet does
                        // not have timestamp we want to catch this here.
                        if (sent_time.is_not_a_date_time() ||
                            rcvd_time.is_not_a_date_time()) {
                            isc_throw(InvalidOperation,
                                      "packet time is not set");
                        }
                        // Calculate durations of packets from beginning of epoch.
                        time_period sent_period(boot_time_, sent_time);
                        time_period rcvd_period(boot_time_, rcvd_time);
                        // Print timestamps for sent and received packet.
                        std::cout << "sent / received: "
                                  << to_iso_string(sent_period.length())
                                  << " / "
                                  << to_iso_string(rcvd_period.length())
                                  << std::endl;
                        break;
                    }
                }
            }
        }
 
    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.
                 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_;    
        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;
    typedef typename std::map<std::string, CustomCounterPtr> CustomCountersMap;
    typedef typename CustomCountersMap::const_iterator CustomCountersMapIterator;
 
    StatsMgr(const bool archive_enabled = false) :
        exchanges_(),
        archive_enabled_(archive_enabled),
        boot_time_(boost::posix_time::microsec_clock::universal_time()) {
    }
 
    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 boost::shared_ptr<T>& packet) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        xchg_stats->appendSent(packet);
    }
 
    boost::shared_ptr<T>
    passRcvdPacket(const ExchangeType xchg_type,
                   const boost::shared_ptr<T>& packet) {
        ExchangeStatsPtr xchg_stats = getExchangeStats(xchg_type);
        boost::shared_ptr<T> 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());
    }
 
 
    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;
    }
 
    static std::string exchangeToString(ExchangeType xchg_type) {
        switch(xchg_type) {
        case XCHG_DO:
            return("DISCOVER-OFFER");
        case XCHG_RA:
            return("REQUEST-ACK");
        case XCHG_RNA:
            return("REQUEST-ACK (renewal)");
        case XCHG_SA:
            return("SOLICIT-ADVERTISE");
        case XCHG_RR:
            return("REQUEST-REPLY");
        case XCHG_RN:
            return("RENEW-REPLY");
        case XCHG_RL:
            return("RELEASE-REPLY");
        default:
            return("Unknown exchange type");
        }
    }
 
     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: " << exchangeToString(it->first)
                      << "***" << std::endl;
            xchg_stats->printMainStats();
            std::cout << std::endl;
            xchg_stats->printRTTStats();
            std::cout << std::endl;
        }
    }
 
    void printIntermediateStats() const {
        std::ostringstream stream_sent;
        std::ostringstream stream_rcvd;
        std::ostringstream stream_drops;
        std::string sep("");
        for (ExchangesMapIterator it = exchanges_.begin();
             it != exchanges_.end(); ++it) {
 
            if (it != exchanges_.begin()) {
                sep = "/";
            }
            stream_sent << sep << it->second->getSentPacketsNum();
            stream_rcvd << sep << it->second->getRcvdPacketsNum();
            stream_drops << sep << it->second->getDroppedPacketsNum();
        }
        std::cout << "sent: " << stream_sent.str()
                  << "; received: " << stream_rcvd.str()
                  << "; drops: " << stream_drops.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: "
                      << exchangeToString(it->first)
                      << "***" << std::endl;
            xchg_stats->printTimestamps();
            std::cout << std::endl;
        }
    }
 
    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;
        }
    }
 
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_; 
};
 
} // namespace perfdhcp
} // namespace isc
 
#endif // STATS_MGR_H