CongestionController.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_comm_CongestionController_hpp
#define anna_comm_CongestionController_hpp

#include <utility>

#include <anna/config/defines.hpp>
#include <anna/core/Singleton.hpp>
#include <anna/core/mt/NRMutex.hpp>
#include <anna/core/util/Average.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace comm {

class ClientSocket;

namespace handler {
class LocalConnection;
}

class CongestionController : public Singleton <CongestionController> {
public:
  static const int MaxLevel = 4;

  struct Advice {
    enum _v {
      None, 
      Process, 
      Discard 
    };
  };

  struct Mode {
    enum _v {
      Auto, 
      Local, 
      Global 
    };
  };

  typedef std::pair <int, int> Workload;

  static const int DefaultLimit = 60;

  static const int MaxPendingBytes;

  Mode::_v getMode() const { return a_mode; }

  int getMessageCounter() const { return a_messageCounter; }

  int getSuccessCounter() const { return a_messageCounter - a_discardedCounter; }

  void setLimit(const int limit) ;

  void setMode(const Mode::_v mode) {
    if((a_mode = mode) == Mode::Auto) {
      WHEN_MULTITHREAD(a_effectiveMode = Mode::Local);
      WHEN_SINGLETHREAD(a_effectiveMode = Mode::Global);
    } else
      a_effectiveMode = mode;
  }

  bool isEmpty() const { return a_avgWorkload.isEmpty(); }

  void setMaxPendingBytes(const int maxPendingBytes) noexcept(false);

  Advice::_v getAdvice(const ClientSocket& clientSocket) ;

  Advice::_v getAdvice(const ClientSocket* clientSocket) {
    return (clientSocket == NULL) ? Advice::Process : getAdvice(*clientSocket);
  }

  Workload getAccumulatedWorkload() const ;

  Workload getCurrentWorkload(const ClientSocket& clientSocket) const ;

  xml::Node* asXML(xml::Node* parent) const ;

  static int getLoad(const Workload& workload) { return workload.second; }

  static int getLevel(const Workload& workload) { return workload.first; }

private:
  static const Millisecond DelayTrace;
  static const int UnusedPendingBytes = -1;
  static const Millisecond HeartBeat;

  //----------------------------------------------------------------------------------
  // a_limit: % de ocupacion maxima al que vamos a limitar los canales.
  // a_discardLevel: Valor maximo del % de cada nivel de descarte. 0 = 25, 1 = 50,
  // 2 = 85, 3 = 99
  //----------------------------------------------------------------------------------
  int a_limit;
  int a_discardLevel [MaxLevel];
  int a_percentage [MaxLevel];
  NRMutex a_mutex;
  Mode::_v a_mode;
  Mode::_v a_effectiveMode;
  Average <unsigned int> a_avgWorkload;
  unsigned int a_messageCounter;
  unsigned int a_discardedCounter;
  mutable Millisecond a_timeTrace;
  int a_maxPendingBytes;
  int a_incomingSocketCounter;
  Millisecond a_tickTime;

  void incrementIncomingSocket() noexcept(false);
  void decrementIncomingSocket() noexcept(false);

  CongestionController();
  CongestionController(const CongestionController&);

  int calculeWorkload(const ClientSocket&) const ;

  friend class Singleton <CongestionController>;

  friend class ClientSocket;
  // getUpdatePeriod

  friend class handler::LocalConnection;
  // incrementIncomingSocket, decrementIncomingSocket
};

}
}

#endif