ResourceUsageManager.cpp

Go to the documentation of this file.

#include "ResourceUsageManager.hpp"
#include "HandlerTypes.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
void ResourceUsageManager::add(const std::string& identity, ResourceUsageCollection& collection, const ResourceUsageData& resourceUsageData, size_t maxSize)
{
  collection.push_back(resourceUsageData);
  if (maxSize && maxSize < collection.size())
  {
    while (maxSize < collection.size())
    {
      collection.pop_front();
    }
  }
  weights.insert(std::map<std::string, Weights>::value_type(identity, Weights()));
}
//-----------------------------------------------------------------------------
void ResourceUsageManager::add(const std::string& identity, ResourceUsageCollection& collection, const std::string& resources, size_t maxSize)
{
  HCE::handlers::DictionaryConverter<std::string, double> converter(resources);
  add(identity, collection, converter.toObject().cast<HCE::handlers::ResourceUsageData>(), maxSize);
}
//-----------------------------------------------------------------------------
ResourceUsageData ResourceUsageManager::calculateAverage(const std::string& identity, ResourceUsageCollection& collection)
{
  ResourceUsageData resourceUsageData;
  size_t count = 0;
  double diff = abs(weights[identity].last-weights[identity].prev);

  std::stringstream outMsg;
  if (diff != weights[identity].diff)
  {
    outMsg << "calculateAverage  (" << diff << " vs. " << weights[identity].diff << ") identity: " << identity << " steps:{ ";

    for(std::vector<size_t>::reverse_iterator iter=steps.rbegin();iter!=steps.rend();++iter)
      outMsg << (*iter) << " ";
  }

  if (diff > weights[identity].diff*2)
  {
    count = nextStep(identity);
  }
  else
  {
    count = prevStep(identity);
  }

  if (diff != weights[identity].diff)
  {
    outMsg << "} [" << weights[identity].stepIndex << "] = " << count;
    logger.log(NODE_LOG_MODE_TRACE) << outMsg.str() << flush;
  }

  resourceUsageData = averageValue(collection, count);

  weights[identity].diff = diff;
  weights[identity].prev = weights[identity].last;

  return resourceUsageData;
}
//-----------------------------------------------------------------------------
ResourceUsageData ResourceUsageManager::averageValue(ResourceUsageCollection& collection, size_t count)
{
  ResourceUsageData resourceUsageData;
  size_t index = 0;
  for (ResourceUsageCollection::reverse_iterator iter=collection.rbegin();iter!=collection.rend();++iter)
  {
    resourceUsageData += (*iter);
    if (++index >= count)
      break;
  }
  resourceUsageData /= (count < collection.size())?count:collection.size();
  return resourceUsageData;
}
//-----------------------------------------------------------------------------
bool ResourceUsageManager::isAllowedRange(const std::string& identity, double maxAllowedRange)
{
  bool result = false;

  std::vector<double> listWeights = weights[identity].listWeights;

  std::stringstream outMsg;
  outMsg << "WEIGHTS RANGE: ";
  for (size_t i=0;i<listWeights.size();++i)
    outMsg << listWeights[i] << " ";
  outMsg << "\t";

  if (listWeights.size())
  {
    auto range = std::minmax_element(listWeights.begin(),listWeights.end());

    outMsg << "MIN: " << (*range.first) << "\tMAX: " << (*range.second);

    if (*range.second)
    {
      double resourceUsageRange = (*range.second-*range.first)*100/(*range.second);

      outMsg << "\tmaxAllowedRange: " << maxAllowedRange << "\tresourceUsageRange: " << resourceUsageRange;

      if (maxAllowedRange > resourceUsageRange && resourceUsageRange)
      {
        result = true;
      }
    }
  }
  logger.log(NODE_LOG_MODE_TRACE) << outMsg.str() << flush;
  return result;
}
//-----------------------------------------------------------------------------
ResourceUsageManager::ResourceUsageManager(HCE::LoggerStream& logger_)
: maxSize(0), steps(), weights(), logger(logger_)
{
  setMaxSize(MAX_SIZE);
}
//-----------------------------------------------------------------------------
void ResourceUsageManager::setMaxSize(size_t maxSize_)
{
  maxSize=maxSize_;
  steps.clear();
  size_t index = maxSize;
  while(index > 0)
  {
    steps.push_back(index);
    index /= 2;
  }
}
//-----------------------------------------------------------------------------
size_t ResourceUsageManager::nextStep(const std::string& identity)
{
  if (weights[identity].stepIndex+1 < steps.size())
    ++(weights[identity].stepIndex);
  return steps[weights[identity].stepIndex];
}
//-----------------------------------------------------------------------------
size_t ResourceUsageManager::prevStep(const std::string& identity)
{
  if (weights[identity].stepIndex > 0)
    --(weights[identity].stepIndex);
  return steps[weights[identity].stepIndex];
}
//-----------------------------------------------------------------------------
void ResourceUsageManager::setLastWeight(const std::string& identity, double weight)
{
        weights[identity].last = weight;
}
//-----------------------------------------------------------------------------
double ResourceUsageManager::getLastWeight(const std::string& identity)
{
        double result = 0.0;
        std::map<std::string, Weights>::iterator iter = weights.find(identity);
        if (iter != weights.end())
                result = (*iter).second.last;
        return result;
}
//-----------------------------------------------------------------------------
void ResourceUsageManager::setListWeights(const std::string& identity, const std::vector<double>& listWeights)
{
  weights[identity].listWeights = listWeights;
}
//-----------------------------------------------------------------------------
std::vector<double> ResourceUsageManager::getListWeights(const std::string& identity)
{
  std::vector<double> listWeights;
  std::map<std::string, Weights>::iterator iter = weights.find(identity);
  if (iter != weights.end())
    listWeights = (*iter).second.listWeights;
  return listWeights;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE