include/wipal/wifi/stats/sta_counters.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef WIFI_STATS_STA_COUNTERS_HXX_
# define WIFI_STATS_STA_COUNTERS_HXX_

# include <boost/foreach.hpp>
# include <boost/format.hpp>

# include <wipal/wifi/stats/sta_counters.hh>

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      inline
      sta_counters::sta_counters(const on_off_data* ood): ood_ (ood)
      {
      }

      template <class Frame>
      void
      sta_counters::account_frame(const Frame&                  ,
                                  const size_t&                 len80211,
                                  const type::frame_type&       ,
                                  const unsigned&               ,
                                  const bool&                   ,
                                  const addr* const&            ,
                                  const addr* const&            transmitter,
                                  const bool&                   )
      {
        if (not transmitter)
          return;

        counters&       s = states_[*transmitter];

        ++s.count;
        s.size += len80211;
      }

      inline
      std::ostream&
      sta_counters::print(std::ostream& os) const
      {
        os << "begin per STA counters\n\n";

        print(os, "STA counters sorted by traffic",
              sorted_states<size_less>()) << '\n';

        print(os, "STA counters sorted by on time",
              sorted_states<time_on_less>(ood_)) << '\n';

        print(os, "STA counters sorted by avg. rate when on",
              sorted_states<avg_rate_less>(ood_));

        return os << "end per STA counters" << std::endl;
      }

      inline
      sta_counters::counters::counters(): count (0), size (0)
      {
      }

      inline
      bool
      sta_counters::
      size_less::operator () (const states::const_iterator& lhs,
                              const states::const_iterator& rhs) const
      {
        const uint64_t  l = lhs->second.size;
        const uint64_t  r = rhs->second.size;

        if (l < r)
          return true;
        return l == r? lhs->first < rhs->first: false;
      }

      inline
      sta_counters::
      avg_rate_less::avg_rate_less(const on_off_data* ood): ood_ (ood)
      {
      }

      inline
      bool
      sta_counters::
      avg_rate_less::operator () (const states::const_iterator& lhs,
                                  const states::const_iterator& rhs) const
      {
        const double    dmax = std::numeric_limits<double>::max();

        const double    l_on = ood_->time_on(lhs->first).get_d();
        const double    r_on = ood_->time_on(rhs->first).get_d();

        const double    l = l_on? lhs->second.size / l_on: dmax;
        const double    r = r_on? rhs->second.size / r_on: dmax;

        if (l < r)
          return true;
        return l == r? lhs->first < rhs->first: false;
      }

      inline
      sta_counters::
      time_on_less::time_on_less(const on_off_data* ood): ood_ (ood)
      {
      }

      inline
      bool
      sta_counters::
      time_on_less::operator () (const states::const_iterator& lhs,
                                 const states::const_iterator& rhs) const
      {
        const tool::microseconds        l = ood_->time_on(lhs->first);
        const tool::microseconds        r = ood_->time_on(rhs->first);

        if (l < r)
          return true;
        return l == r? lhs->first < rhs->first: false;
      }

      template <class Set>
      std::ostream&
      sta_counters::print(std::ostream&         os,
                          const std::string&    name,
                          const Set&            set) const
      {
        const double    step    = 1 / double (set.size());

        boost::format   fmt ("%17s  %11s  %11s  %11s  %11s  %11s  %11s"
                             " %11s %11s\n");
        double          prop = 0;
        double          size_cumul = 0;
        double          avg_rate_cumul = 0;

        os << "  begin " << name << '\n';

        for (typename Set::const_reverse_iterator i = set.rbegin();
             i != set.rend();
             ++i)
          {
            const double        ton = ood_->time_on((*i)->first).get_d();
            const double        size = (*i)->second.size;
            const double        count = (*i)->second.count;

            assert(size);

            /* Note that ton might be 0 (e.g. trace has only one
             * packet).  In this case avg_rate should be set to
             * infinity.
             */
            const double        avg_rate = size / ton;
            const double        avg_fptu = count / ton;

            prop += step;
            size_cumul += size;
            avg_rate_cumul += avg_rate;

            os << (fmt  % (*i)->first % size % avg_rate % ton
                        % prop % size_cumul % avg_rate_cumul
                        % count % avg_fptu);
          }
        return os << "  end " << name << '\n';
      }

      template <class Less>
      std::set<sta_counters::states::const_iterator, Less>
      sta_counters::sorted_states(const Less& less) const
      {
        std::set<states::const_iterator, Less>  r (less);

        for (states::const_iterator i = states_.begin();
             i != states_.end();
             ++i)
          r.insert(i);

        return r;
      }

    } // End of namespace wpl::wifi::stats.

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_STA_COUNTERS_HXX_

---