algorithm_statistics.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <cmath>

#include <config/global_definitions.hpp>
#include <config/configuration.hpp>

#include <core/algorithm_statistics.hpp>

#include <boost/filesystem.hpp>

using namespace std;

namespace hype{
   namespace core{


      AlgorithmStatistics::AlgorithmStatistics() : executionHistory_(), 
                                                   relative_errors_(), 
                                                   number_of_recomputations_(0), 
                                                   number_of_decisions_for_this_algorithm_(0), 
                                                   average_relative_error_(0), 
                                                   total_execution_time_(0),
                                                   number_of_terminated_executions_of_this_algorithm_(0){

      }

bool AlgorithmStatistics::writeToDisc(const std::string& operation_name, const std::string& algorithm_name) const{
   const std::string output_dir_name="output";
   if(!boost::filesystem::exists(output_dir_name)){
      if(!quiet) cout << "create Directory '" << output_dir_name << "'" << endl;
      if(!boost::filesystem::create_directory(output_dir_name)){
         cout << "HyPE Library: Failed to created Output Directory '" << output_dir_name << "' for operation statistics, skipping the write operation for statistical data for operation '" << operation_name << "'" << endl;
      }
   }     
      
   std::string dir_name=output_dir_name+"/";
   dir_name+=operation_name;
   dir_name+="/";


   if(!boost::filesystem::create_directory(dir_name) && !quiet)
      std::cout << "Directory '" << dir_name << "' already exists!" << std::endl;
   
   dir_name+=algorithm_name;
   
   if(!boost::filesystem::create_directory(dir_name) && !quiet)
      std::cout << "Directory '" << dir_name << "' already exists!" << std::endl;


   std::string basic_file_name=dir_name+"/";
   //basic_file_name+=algorithm_name;
   
   std::string file_name_measurement_pairs=basic_file_name+"measurement_pairs.data";
   fstream file(file_name_measurement_pairs.c_str(),std::ios_base::out | std::ios_base::trunc);
   executionHistory_.store(file);
   
   std::string file_name_relative_errors=basic_file_name+"relative_errors.data";
   fstream file_rel_err(file_name_relative_errors.c_str(),std::ios_base::out | std::ios_base::trunc);
   
   std::vector<double> average_estimation_errors;

   //TODO: NOTE: here is somewere an ERROR, because for some 
   double sum=0;
   unsigned int length_of_initial_training_phase=Runtime_Configuration::instance().getTrainingLength(); //Configuration::period_for_periodic_recomputation;
   for(unsigned int i=length_of_initial_training_phase+1;i<relative_errors_.size();i++){
      file_rel_err << (i-length_of_initial_training_phase) << "\t" << relative_errors_[i] << std::endl;
      sum+=abs(relative_errors_[i]);
      average_estimation_errors.push_back(sum/double(i-length_of_initial_training_phase+1)); //compute average estimation error after each execution of the algorithm, so we can plot it over "time"
   }
   
   std::string file_name_average_relative_errors=basic_file_name+"average_relative_errors.data";
   fstream file_average_rel_err(file_name_average_relative_errors.c_str(),std::ios_base::out | std::ios_base::trunc);

   for(unsigned int i=length_of_initial_training_phase;i<average_estimation_errors.size();i++){
      file_average_rel_err  << (i-length_of_initial_training_phase) << "\t" << average_estimation_errors[i] << std::endl;
   }

   //code to compute windowed average relative estimation errors 
   std::string file_name_windowed_average_relative_errors=basic_file_name+"windowed_average_relative_errors.data";
   if(!quiet) cout << "File: " << file_name_windowed_average_relative_errors << endl;
   fstream file_average_windowed_rel_err(file_name_windowed_average_relative_errors.c_str(),std::ios_base::out | std::ios_base::trunc);

   assert(Runtime_Configuration::instance().getRelativeErrorWindowSize()>0);
   for(unsigned int i=length_of_initial_training_phase;i<relative_errors_.size();i++){
      double sum=0;
      if((int)i < (int)relative_errors_.size()-(int)Runtime_Configuration::instance().getRelativeErrorWindowSize()){
         for(unsigned int j=0;j<Runtime_Configuration::instance().getRelativeErrorWindowSize();j++){
            sum+=abs(relative_errors_[i+j]);
         }

      }
      file_average_windowed_rel_err  << (i-length_of_initial_training_phase)  << "\t" << sum/double(Runtime_Configuration::instance().getRelativeErrorWindowSize()) << std::endl; //compute average estimation error after each execution of the algorithm, so we can plot it over "time"
   }



   //output report for algorithm
   cout << "==========================================================================" << endl
        << "Report for Algorithm '" << algorithm_name << "'" << endl
        << "Average Relative Error: " << sum/double(relative_errors_.size()) << endl
        << "Number of Recomputations: " << number_of_recomputations_ << endl
        << "Number of Decisions for this Algorithm: " << number_of_decisions_for_this_algorithm_ << endl
        << "Total Execution Time of this Algorithm: " << total_execution_time_ << "ns" << endl
        //<< "**************************************************************************" 
        << endl;
   



   
   return true;
}

   };//end namespace core
}; //end namespace hype