diff --git a/Makefile.am b/Makefile.am index dd4c69e..cb789ce 100644 --- a/Makefile.am +++ b/Makefile.am @@ -161,8 +161,11 @@ src_backend_libbackend_la_LIBADD = \ src_backend_libbackend_la_SOURCES = \ src/backend/concrete_environment.cc \ src/backend/concrete_history.cc \ + src/backend/concrete_process_statistics.cc \ src/backend/concrete_simulation.cc \ + src/backend/concrete_simulation_statistics.cc \ src/backend/concrete_statistics.cc \ + src/backend/concrete_thread_statistics.cc \ src/backend/cpu_policies_gatekeeper.cc \ src/backend/cpu_policy.cc \ src/backend/cpu_policy_exception.cc \ @@ -206,6 +209,7 @@ src_backend_libbackend_la_SOURCES = \ src/backend/serializers_gatekeeper.cc \ src/backend/simulation.cc \ src/backend/simulation_observer.cc \ + src/backend/simulation_statistics.cc \ src/backend/static_process.cc \ src/backend/static_request.cc \ src/backend/static_resource.cc \ @@ -241,6 +245,7 @@ pkginclude_HEADERS += \ src/backend/sgpemv2/policy_parameters.hh \ src/backend/sgpemv2/plugin.hh \ src/backend/sgpemv2/plugin_manager.hh \ + src/backend/sgpemv2/process_statistics.hh \ src/backend/sgpemv2/ready_queue.hh \ src/backend/sgpemv2/request.hh \ src/backend/sgpemv2/resource.hh \ @@ -260,10 +265,12 @@ pkginclude_HEADERS += \ src/backend/sgpemv2/serializers_gatekeeper.hh \ src/backend/sgpemv2/simulation.hh \ src/backend/sgpemv2/simulation_observer.hh \ + src/backend/sgpemv2/simulation_statistics.hh \ src/backend/sgpemv2/statistics.hh \ src/backend/sgpemv2/string_utils.hh \ src/backend/sgpemv2/sub_request.hh \ src/backend/sgpemv2/thread.hh \ + src/backend/sgpemv2/thread_statistics.hh \ src/backend/sgpemv2/user_interrupt_exception.hh @@ -272,22 +279,24 @@ pkginclude_HEADERS += \ noinst_HEADERS += \ src/backend/concrete_environment.hh \ src/backend/concrete_history.hh \ + src/backend/concrete_process_statistics.hh \ src/backend/concrete_simulation.hh \ + src/backend/concrete_simulation_statistics.hh \ src/backend/concrete_statistics.hh \ + src/backend/concrete_thread_statistics.hh \ src/backend/dynamic_process.hh \ src/backend/dynamic_request.hh \ src/backend/dynamic_resource.hh \ src/backend/dynamic_schedulable.hh \ src/backend/dynamic_sub_request.hh \ src/backend/dynamic_thread.hh \ - src/backend/process_statistics.hh \ src/backend/static_process.hh \ src/backend/static_request.hh \ src/backend/static_resource.hh \ src/backend/static_schedulable.hh \ src/backend/static_sub_request.hh \ - src/backend/static_thread.hh \ - src/backend/thread_statistics.hh + src/backend/static_thread.hh + # ############################################################ @@ -334,9 +343,11 @@ sgpemv2_SOURCES = \ src/ready_queue_widget.cc \ src/resources_widget.cc \ src/schedulable_state_widget.cc \ + src/schedulables_statistics_widget.cc \ src/schedulables_tree_widget.cc \ - src/simulation_controller.cc \ + src/simulation_controller.cc \ src/simulation_widget.cc \ + src/statistics_container_window.cc \ src/text_simulation.cc noinst_HEADERS += \ @@ -354,9 +365,11 @@ noinst_HEADERS += \ src/ready_queue_widget.hh \ src/resources_widget.hh \ src/schedulable_state_widget.hh \ + src/schedulables_statistics_widget.hh \ src/schedulables_tree_widget.hh \ - src/simulation_controller.hh \ + src/simulation_controller.hh \ src/simulation_widget.hh \ + src/schedulables_statistics_widget.hh \ src/text_simulation.hh # ---------- glade files ----------- diff --git a/src/backend/concrete_process_statistics.cc b/src/backend/concrete_process_statistics.cc new file mode 100644 index 0000000..d9bd66a --- /dev/null +++ b/src/backend/concrete_process_statistics.cc @@ -0,0 +1,207 @@ +// src/backend/concrete_process_statistics.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#include "concrete_process_statistics.hh" +#include "concrete_thread_statistics.hh" +#include +#include +#include +#include +#include +#include + +#include + +using namespace std; +using namespace sgpem; + +/** + The constructor executes all calculations examinating or only the Thred object, + or the whole History + + \param core The process whose statistics we are going to calculate + \param instant The instant statistics will refer to + \param _threads_stats The statistics of the threads belonging to "core" + +*/ +ConcreteProcessStatistics::ConcreteProcessStatistics(const Process* core, const int& instant): + _core(core) +{ + //retrieve threads statistics necessary to calculate "core"'s statistics + vector threads = core->get_threads(); + for (uint i_t = 0; i_t < threads.size(); i_t++) + _threads_stats.push_back(ConcreteThreadStatistics(threads[i_t], instant)); + + + //inizialize variables + _total_inactivity = 0; + _execution_time = 0; + _response_time = -1; + _turn_around = 0; + _resource_usage_time = 0; + _resource_waitings_time = 0; + _average_response_time = 0; + int min_reponse = -1; //useful for _response_time + int arrived_threads = 0; //useful for _average_response_time + bool someone_began = false; //useful for _response_time + + //iterate through threads statistics + vector::const_iterator i; + for(i = _threads_stats.begin(); i != _threads_stats.end(); i++) + { + Thread* t = const_cast((*i).get_core()); + if (t->get_process() == *core) + { //found a thread belonging to "core" + + _execution_time += (*i).get_execution_time(); + _resource_usage_time += (*i).get_resource_usage_time(); + + if ((*i).get_response_time() != -1) + { + _average_response_time += (*i).get_response_time(); + arrived_threads++; + } + + if ((*i).get_response_time() != -1 && someone_began == false) + { + someone_began = true; + min_reponse = (*i).get_response_time(); + } + + if(someone_began && (*i).get_response_time() != -1 && (*i).get_response_time() + (*i).get_real_arrival_time() < min_reponse) + min_reponse = (*i).get_response_time() + (*i).get_real_arrival_time(); + + if ((*i).get_real_arrival_time() + (*i).get_execution_time() + (*i).get_total_inactivity() > _turn_around) + _turn_around = (*i).get_real_arrival_time() + (*i).get_execution_time() + (*i).get_total_inactivity(); + } + } + + //******* AAARRRGGHH!!! + //We have to iterate the whole History ONLY to retreive _resource_waitings_time !! + // + const History& hist = Simulation::get_instance().get_history(); + for (int time=0; time < instant; time++) + { + const Environment& env = hist.get_environment_at(time); + const vector procs = env.get_processes(); + + for (uint i_p=0; i_p < procs.size(); i_p++) + if (*procs[i_p] == *core && procs[i_p]->get_state() == Schedulable::state_blocked) + _resource_waitings_time++; + } + + + + //set other variables + if(core->get_total_cpu_time() != 0) + _execution_progress = (_execution_time*100) / core->get_total_cpu_time(); + else + _execution_progress = 0; + + _total_inactivity = _turn_around - _execution_time; + + if (_turn_around == 0) + _efficency = -1; + else + _efficency = (_execution_time*100)/_turn_around; + + _response_time = min_reponse; + + if (arrived_threads != 0) + _average_response_time = (float)((int)((_average_response_time/arrived_threads)*100))/100; +} + + +ConcreteProcessStatistics::~ConcreteProcessStatistics() +{ +} + +int +ConcreteProcessStatistics::get_execution_time() const +{ + return _execution_time; +} + +int +ConcreteProcessStatistics::get_execution_progress() const +{ + return _execution_progress; +} + +int +ConcreteProcessStatistics::get_total_inactivity() const +{ + return _total_inactivity; +} + +int +ConcreteProcessStatistics::get_response_time() const +{ + return _response_time; +} + +int +ConcreteProcessStatistics::get_turn_around() const +{ + return _turn_around; +} + +int +ConcreteProcessStatistics::get_efficency() const +{ + return _efficency; +} + +int +ConcreteProcessStatistics::get_resource_usage_time() const +{ + return _resource_usage_time; +} + +int +ConcreteProcessStatistics::get_resource_waitings_time() const +{ + return _resource_waitings_time; +} + +float +ConcreteProcessStatistics::get_average_response_time() const +{ + return _average_response_time; +} + +const Process* +ConcreteProcessStatistics::get_core() const +{ + return _core; +} + +/** + \warning Don't delete these pointers!! + \warning These pointers are not valid anymore after the destruction of "this" +*/ +vector +ConcreteProcessStatistics::get_threads_statistics() const +{ + vector rit; + for (uint i=0; i < _threads_stats.size(); i++) + rit.push_back(&_threads_stats[i]); + return rit; +} diff --git a/src/backend/process_statistics.hh b/src/backend/concrete_process_statistics.hh similarity index 65% rename from src/backend/process_statistics.hh rename to src/backend/concrete_process_statistics.hh index 70fc578..a35383a 100644 --- a/src/backend/process_statistics.hh +++ b/src/backend/concrete_process_statistics.hh @@ -1,4 +1,4 @@ -// src/backend/process_statistics.hh - Copyright 2005, 2006, University +// src/backend/concrete_process_statistics.hh - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // @@ -18,26 +18,25 @@ // along with SGPEMv2; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -#ifndef PROCESS_STATISTICS_HH -#define PROCESS_STATISTICS_HH 1 +#ifndef CONCRETE_PROCESS_STATISTICS_HH +#define CONCRETE_PROCESS_STATISTICS_HH 1 #include "config.h" -#include "sgpemv2/schedulable_statistics.hh" -#include "sgpemv2/process.hh" -#include "thread_statistics.hh" -#include - -#include +#include +#include +#include "concrete_thread_statistics.hh" namespace sgpem { - class ProcessStatistics : public SchedulableStatistics + class ConcreteStatistics; + + class ConcreteProcessStatistics : public ProcessStatistics { public: - ProcessStatistics(const Process* core, const int& instant); - ~ProcessStatistics(); + friend class ConcreteStatistics; + ~ConcreteProcessStatistics (); int get_execution_time() const; int get_execution_progress() const; @@ -50,14 +49,14 @@ namespace sgpem int get_resource_waitings_time() const; const Process* get_core() const; - - std::vector get_threads_statistics() const; - + + std::vector get_threads_statistics() const; private: + ConcreteProcessStatistics (const Process* core, const int& instant); - const Process* _core; - float _average_response_time; - std::vector _threads_stats; + const Process* _core; + float _average_response_time; + std::vector _threads_stats; }; } diff --git a/src/backend/concrete_simulation_statistics.cc b/src/backend/concrete_simulation_statistics.cc new file mode 100644 index 0000000..0f7653b --- /dev/null +++ b/src/backend/concrete_simulation_statistics.cc @@ -0,0 +1,110 @@ +// src/backend/concrete_simulation_statistics.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#include "concrete_simulation_statistics.hh" +#include + +#include + +using namespace std; +using namespace sgpem; + +ConcreteSimulationStatistics::~ConcreteSimulationStatistics() +{ +} + +ConcreteSimulationStatistics::ConcreteSimulationStatistics(const std::vector proc_stats, const int& instant) +{ + _average_inactivity_time = 0; + _average_turn_around = 0; + _average_response_time = 0; + _average_efficency = 0; + _terminated_processes = 0; + _terminated_threads = 0; + _average_throughput = 0; + + int schedulables_count = 0; + + vector::const_iterator p; + for (p = proc_stats.begin(); p != proc_stats.end(); p++) + { + schedulables_count++; + + _average_response_time += p->get_response_time(); + /* + vector Tstats = Pstats.get_threads_statistics(); + for (uint t=0; t < Tstats.size(); t++) + { + schedulables_count++; + _average_response_time += Tstats[t].get_response_time(); + } + */ + } + + +} + + + + +float +ConcreteSimulationStatistics::get_average_inactivity_time() const +{ + return _average_inactivity_time; +} + +float +ConcreteSimulationStatistics::get_average_turn_around() const +{ + return _average_turn_around; +} + +float +ConcreteSimulationStatistics::get_average_response_time() const +{ + return _average_response_time; +} + +float +ConcreteSimulationStatistics::get_average_efficency() const +{ + return _average_efficency; +} + +int +ConcreteSimulationStatistics::get_terminated_processes() const +{ + return _terminated_processes; +} + +int +ConcreteSimulationStatistics::get_terminated_threads() const +{ + return _terminated_threads; +} + +float +ConcreteSimulationStatistics::get_average_throughput() const +{ + return _average_throughput; +} + + + diff --git a/src/backend/concrete_simulation_statistics.hh b/src/backend/concrete_simulation_statistics.hh new file mode 100644 index 0000000..2edfbc3 --- /dev/null +++ b/src/backend/concrete_simulation_statistics.hh @@ -0,0 +1,66 @@ +// src/backend/concrete_simulation_statistics.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef CONCRETE_SIMULATION_STATISTICS_HH +#define CONCRETE_SIMULATION_STATISTICS_HH 1 + +#include "config.h" + +#include +#include "concrete_process_statistics.hh" + + +namespace sgpem +{ + class ConcreteStatistics; + + class ConcreteSimulationStatistics : public SimulationStatistics + { + public: + friend class ConcreteStatistics; + + ~ConcreteSimulationStatistics(); + + float get_average_inactivity_time() const ; + float get_average_turn_around() const ; + float get_average_response_time() const ; + float get_average_efficency() const ; + int get_terminated_processes() const ; + int get_terminated_threads() const ; + float get_average_throughput() const ; + + protected: + ConcreteSimulationStatistics(const std::vector proc_stats, const int& instant); + + float _average_inactivity_time ; + float _average_turn_around ; + float _average_response_time ; + float _average_efficency ; + int _terminated_processes ; + int _terminated_threads ; + float _average_throughput ; + }; +} + + +#endif + + + \ No newline at end of file diff --git a/src/backend/concrete_statistics.cc b/src/backend/concrete_statistics.cc index 6293f77..f87600b 100644 --- a/src/backend/concrete_statistics.cc +++ b/src/backend/concrete_statistics.cc @@ -19,55 +19,61 @@ // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "concrete_statistics.hh" -#include "sgpemv2/simulation.hh" -#include "sgpemv2/history.hh" -#include "sgpemv2/environment.hh" -#include "sgpemv2/schedulable.hh" -#include "sgpemv2/process.hh" -#include "sgpemv2/thread.hh" -#include "thread_statistics.hh" -#include "process_statistics.hh" +#include +#include +#include +#include +#include +#include +#include "concrete_thread_statistics.hh" +#include "concrete_process_statistics.hh" #include using namespace sgpem; using namespace std; -ConcreteStatistics::ConcreteStatistics() -{} - - -vector -ConcreteStatistics::get_process_statistics(const int& instant) const + + +ConcreteStatistics::ConcreteStatistics(): _sim_stats(0) { - //vector thread_stats; - vector rit; + calculateStatisticsAt(-1); +} + +void +ConcreteStatistics::calculateStatisticsAt(const int& instant) +{ + //retrieve all processes + vector procs = Simulation::get_instance().get_history().get_environment_at(0).get_processes(); - const History& hist = Simulation::get_instance().get_history(); - const Environment& env = hist.get_environment_at(instant); - const vector procs = env.get_processes(); + //create all process statistics (which themselves create their thread statistics) + _proc_stats.clear(); + for (uint p = 0; p < procs.size(); p++) + _proc_stats.push_back(ConcreteProcessStatistics(procs[p], instant)); - //first calculate all THREADS statistics - for (uint i_p=0; i_p < procs.size(); i_p++) - { - /*const vector threads = procs[i_p]->get_threads(); - for (uint i_t = 0; i_t < threads.size(); i_t++) - { - ThreadStatistics* s = new ThreadStatistics(threads[i_t], instant); - thread_stats.push_back(s); - rit.push_back(s); - } - */ - rit.push_back(ProcessStatistics(procs[i_p], instant)); - } - /* - //then calculate PROCESSES statistics USING the previous ones - for (uint i_p=0; i_p < procs.size(); i_p++) - { - SchedulableStatistics* s = new ProcessStatistics(procs[i_p], instant, &thread_stats); - rit.push_back(s); - } - */ + if (_sim_stats) + delete _sim_stats; + //create simulation statistics using just obtained process statistics + _sim_stats = new ConcreteSimulationStatistics(_proc_stats, instant); +} + +const SimulationStatistics* +ConcreteStatistics::get_simulation_statistics() const +{ + return _sim_stats; +} + +/** + \warning Don't delete these pointers!! + \warning These pointers are not valid anymore AFTER a call to calculateStatisticsAt +*/ +std::vector +ConcreteStatistics::get_process_statistics() const +{ + vector rit; + for (uint i=0; i < _proc_stats.size(); i++) + rit.push_back(&_proc_stats[i]); return rit; } + diff --git a/src/backend/concrete_statistics.hh b/src/backend/concrete_statistics.hh index c597068..7eafe16 100644 --- a/src/backend/concrete_statistics.hh +++ b/src/backend/concrete_statistics.hh @@ -23,9 +23,12 @@ #include "config.h" -#include "sgpemv2/statistics.hh" -#include +#include +#include "concrete_process_statistics.hh" +#include "concrete_simulation_statistics.hh" +#include +#include namespace sgpem { @@ -36,10 +39,18 @@ namespace sgpem public: ConcreteStatistics(); - std::vector get_process_statistics(const int& instant) const; + void calculateStatisticsAt(const int& instant); + const SimulationStatistics* get_simulation_statistics() const; + std::vector get_process_statistics() const; + + private: + ConcreteSimulationStatistics* _sim_stats; + std::vector _proc_stats; }; } #endif + + diff --git a/src/backend/concrete_thread_statistics.cc b/src/backend/concrete_thread_statistics.cc new file mode 100644 index 0000000..149249a --- /dev/null +++ b/src/backend/concrete_thread_statistics.cc @@ -0,0 +1,193 @@ +// src/backend/concrete_thread_statistics.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#include "concrete_thread_statistics.hh" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace sgpem; + +/** + The constructor executes all calculations examinating or only the Thread object + or the whole History + +*/ +ConcreteThreadStatistics::ConcreteThreadStatistics(const Thread* core, const int& instant): _core(core) +{ + //initializations + _total_inactivity = 0; + _execution_time = 0; + _response_time = -1; + _real_arrival_time = -1; + _turn_around = 0; + _resource_usage_time = 0; + _resource_waitings_time = 0; + + bool iniziato = false; //useful for _response_time + + const History& hist = Simulation::get_instance().get_history(); //prendo la lista delle risorse + const map res = hist.get_environment_at(0).get_resources(); + + //****** iterate through HISTORY to retreive informations + for (int time=0; time < instant; time++) + { + const Environment& env = hist.get_environment_at(time); + const vector procs = env.get_processes(); + + //looks for the process that owns this thread + for (uint i_p=0; i_p < procs.size(); i_p++) + { + const vector threads = procs[i_p]->get_threads(); + //looks for the thread "core" + for (uint i_t = 0; i_t < threads.size(); i_t++) + { + if ( (*threads[i_t]) == (*core) ) //FOUND!! + { + if (threads[i_t]->get_state() == Schedulable::state_running) + { + iniziato = true; + if( _response_time == -1) //arrives and runs immediately + { + _response_time = 0; + _real_arrival_time = time - procs[i_p]->get_arrival_time() -1; + } + _execution_time++; + } + if (threads[i_t]->get_state() != Schedulable::state_future && + threads[i_t]->get_state() != Schedulable::state_terminated) + { + _turn_around++; + if (!iniziato && _response_time == -1) //arrives and doesn't run + { + _response_time = 0; + _real_arrival_time = time - procs[i_p]->get_arrival_time() -1; + } + } + if (threads[i_t]->get_state() == Schedulable::state_blocked + || threads[i_t]->get_state() == Schedulable::state_ready) + { + _total_inactivity++; + if (!iniziato && _response_time != -1) + _response_time++; + + if (threads[i_t]->get_state() == Schedulable::state_blocked) + _resource_waitings_time++; + } + } + } //threads + } //procs + + + //for each resource check requests at this istant: + //if the request of this thread is allocated then increase _resource_usage_time + Environment::Resources::const_iterator res_iter = res.begin(); + while(res_iter != res.end()) + { + Environment::resource_key_t key = (*res_iter).first; + vector req = env.get_request_queue(key); + for (uint i_r=0; i_r < req.size(); i_r++) + if( (*req[i_r]).get_request().get_thread() == (*core) && (*req[i_r]).get_state() == Request::state_allocated) + _resource_usage_time++; + + res_iter++; + } + + }//istants + + //set other variables + _execution_progress = (100*_execution_time)/core->get_total_cpu_time(); + if (_turn_around == 0) + _efficency = -1; + else + _efficency = (_execution_time*100)/_turn_around; +} + + +ConcreteThreadStatistics::~ConcreteThreadStatistics() +{ +} + +int +ConcreteThreadStatistics::get_execution_time() const +{ + return _execution_time; +} + +int +ConcreteThreadStatistics::get_execution_progress() const +{ + return _execution_progress; +} + +int +ConcreteThreadStatistics::get_total_inactivity() const +{ + return _total_inactivity; +} + +int +ConcreteThreadStatistics::get_response_time() const +{ + return _response_time; +} + +int +ConcreteThreadStatistics::get_turn_around() const +{ + return _turn_around; +} + +int +ConcreteThreadStatistics::get_efficency() const +{ + return _efficency; +} + +int +ConcreteThreadStatistics::get_resource_usage_time() const +{ + return _resource_usage_time; +} + +int +ConcreteThreadStatistics::get_resource_waitings_time() const +{ + return _resource_waitings_time; +} + +int +ConcreteThreadStatistics::get_real_arrival_time() const +{ + return _real_arrival_time; +} + +const Thread* +ConcreteThreadStatistics::get_core() const +{ + return _core; +} diff --git a/src/backend/thread_statistics.hh b/src/backend/concrete_thread_statistics.hh similarity index 75% rename from src/backend/thread_statistics.hh rename to src/backend/concrete_thread_statistics.hh index dad1652..b4de1c7 100644 --- a/src/backend/thread_statistics.hh +++ b/src/backend/concrete_thread_statistics.hh @@ -1,4 +1,4 @@ -// src/backend/thread_statistics.hh - Copyright 2005, 2006, University +// src/backend/concrete_thread_statistics.hh - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // @@ -18,24 +18,25 @@ // along with SGPEMv2; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -#ifndef THREAD_STATISTICS_HH -#define THREAD_STATISTICS_HH 1 +#ifndef CONCRETE_THREAD_STATISTICS_HH +#define CONCRETE_THREAD_STATISTICS_HH 1 #include "config.h" -#include "sgpemv2/schedulable_statistics.hh" -#include "sgpemv2/thread.hh" +#include #include namespace sgpem { - class ThreadStatistics : public SchedulableStatistics + class ConcreteProcessStatistics; + + class ConcreteThreadStatistics : public ThreadStatistics { - public: - ThreadStatistics(const Thread* core, const int& instant); - ~ThreadStatistics(); + public: + friend class ConcreteProcessStatistics; + ~ConcreteThreadStatistics(); int get_execution_time() const; int get_execution_progress() const; @@ -51,6 +52,7 @@ namespace sgpem int get_real_arrival_time() const; //useful for ProcessStatistics private: + ConcreteThreadStatistics(const Thread* core, const int& instant); const Thread* _core; int _real_arrival_time; }; diff --git a/src/backend/process_statistics.cc b/src/backend/process_statistics.cc index 0d8bef5..5198a11 100644 --- a/src/backend/process_statistics.cc +++ b/src/backend/process_statistics.cc @@ -18,176 +18,16 @@ // along with SGPEMv2; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -#include "process_statistics.hh" -#include "sgpemv2/simulation.hh" -#include "sgpemv2/history.hh" -#include "sgpemv2/environment.hh" -#include "sgpemv2/schedulable.hh" - -#include - -using namespace std; +#include using namespace sgpem; -/** - The constructor executes all calculations examinating or only the Thred object, - or the whole History - -*/ -ProcessStatistics::ProcessStatistics(const Process* core, const int& instant): _core(core) -{ - // To calculate Process statistics we need the respective thread statistics - // Calculate them! - - vector threads = core->get_threads(); - for (uint i_t = 0; i_t < threads.size(); i_t++) - _threads_stats.push_back(ThreadStatistics(threads[i_t], instant)); - - //inizialize variables - _total_inactivity = 0; - _execution_time = 0; - _response_time = -1; - _turn_around = 0; - _resource_usage_time = 0; - _resource_waitings_time = 0; - _average_response_time = 0; - int min_reponse = -1; //useful for _response_time - int arrived_threads = 0; //useful for _average_response_time - bool someone_began = false; //useful for _response_time - - //iterate through threads statistics - vector::iterator i; - for(i = _threads_stats.begin(); i != _threads_stats.end(); i++) - { - Thread* t = const_cast((*i).get_core()); - if (t->get_process() == *core) - { //found a thread belonging to "core" - - _execution_time += (*i).get_execution_time(); - _resource_usage_time += (*i).get_resource_usage_time(); - - if ((*i).get_response_time() != -1) - { - _average_response_time += (*i).get_response_time(); - arrived_threads++; - } - - if ((*i).get_response_time() != -1 && someone_began == false) - { - someone_began = true; - min_reponse = (*i).get_response_time(); - } - - if(someone_began && (*i).get_response_time() != -1 && (*i).get_response_time() + (*i).get_real_arrival_time() < min_reponse) - min_reponse = (*i).get_response_time() + (*i).get_real_arrival_time(); - - if ((*i).get_real_arrival_time() + (*i).get_execution_time() + (*i).get_total_inactivity() > _turn_around) - _turn_around = (*i).get_real_arrival_time() + (*i).get_execution_time() + (*i).get_total_inactivity(); - } - } - - //******* AAARRRGGHH!!! - //We have to iterate the whole History ONLY to retreive _resource_waitings_time !! - // - const History& hist = Simulation::get_instance().get_history(); - for (int time=0; time < instant; time++) - { - const Environment& env = hist.get_environment_at(time); - const vector procs = env.get_processes(); - - for (uint i_p=0; i_p < procs.size(); i_p++) - if (*procs[i_p] == *core && procs[i_p]->get_state() == Schedulable::state_blocked) - _resource_waitings_time++; - } - - - - //set other variables - if(core->get_total_cpu_time() != 0) - _execution_progress = (_execution_time*100) / core->get_total_cpu_time(); - else - _execution_progress = 0; - - _total_inactivity = _turn_around - _execution_time; - - if (_turn_around == 0) - _efficency = -1; - else - _efficency = (_execution_time*100)/_turn_around; - - _response_time = min_reponse; - - if (arrived_threads != 0) - _average_response_time = (float)((int)((_average_response_time/arrived_threads)*100))/100; -} - ProcessStatistics::~ProcessStatistics() -{ +{ } -int -ProcessStatistics::get_execution_time() const +ProcessStatistics::ProcessStatistics() { - return _execution_time; } -int -ProcessStatistics::get_execution_progress() const -{ - return _execution_progress; -} -int -ProcessStatistics::get_total_inactivity() const -{ - return _total_inactivity; -} - -int -ProcessStatistics::get_response_time() const -{ - return _response_time; -} - -int -ProcessStatistics::get_turn_around() const -{ - return _turn_around; -} - -int -ProcessStatistics::get_efficency() const -{ - return _efficency; -} - -int -ProcessStatistics::get_resource_usage_time() const -{ - return _resource_usage_time; -} - -int -ProcessStatistics::get_resource_waitings_time() const -{ - return _resource_waitings_time; -} - -float -ProcessStatistics::get_average_response_time() const -{ - return _average_response_time; -} - -const Process* -ProcessStatistics::get_core() const -{ - return _core; -} - -vector -ProcessStatistics::get_threads_statistics() const -{ - return _threads_stats; -} diff --git a/src/backend/sgpemv2/process_statistics.hh b/src/backend/sgpemv2/process_statistics.hh new file mode 100644 index 0000000..5f8c8e4 --- /dev/null +++ b/src/backend/sgpemv2/process_statistics.hh @@ -0,0 +1,61 @@ +// src/backend/process_statistics.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef PROCESS_STATISTICS_HH +#define PROCESS_STATISTICS_HH 1 + +#include "config.h" + +#include +#include +#include +#include "thread_statistics.hh" +#include + +#include + + +namespace sgpem +{ + class ProcessStatistics : public SchedulableStatistics + { + public: + ~ProcessStatistics(); + + int get_execution_time() const =0; + int get_execution_progress() const =0; + int get_total_inactivity() const =0; + int get_response_time() const =0; + virtual float get_average_response_time() const =0; + int get_turn_around() const =0; + int get_efficency() const =0; + int get_resource_usage_time() const =0; + int get_resource_waitings_time() const =0; + + const Process* get_core() const =0; + + virtual std::vector get_threads_statistics() const =0; + + protected: + ProcessStatistics(); + }; +} + +#endif diff --git a/src/backend/sgpemv2/simulation_statistics.hh b/src/backend/sgpemv2/simulation_statistics.hh new file mode 100644 index 0000000..09b9842 --- /dev/null +++ b/src/backend/sgpemv2/simulation_statistics.hh @@ -0,0 +1,51 @@ +// src/backend/simulation_statistics.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef SIMULATION_STATISTICS_HH +#define SIMULATION_STATISTICS_HH 1 + +#include "config.h" + + +namespace sgpem +{ + class SimulationStatistics + { + public: + virtual ~SimulationStatistics(); + + virtual float get_average_inactivity_time() const =0; + virtual float get_average_turn_around() const =0; + virtual float get_average_response_time() const =0; + virtual float get_average_efficency() const =0; + virtual int get_terminated_processes() const =0; + virtual int get_terminated_threads() const =0; + virtual float get_average_throughput() const =0; + + protected: + + SimulationStatistics(); + }; +} + +#endif + + + diff --git a/src/backend/sgpemv2/statistics.hh b/src/backend/sgpemv2/statistics.hh index 27a751e..dec07d2 100755 --- a/src/backend/sgpemv2/statistics.hh +++ b/src/backend/sgpemv2/statistics.hh @@ -22,8 +22,9 @@ #define STATISTICS_HH 1 #include "config.h" -#include "sgpemv2/templates/singleton.hh" -#include "process_statistics.hh" +#include +#include +#include #include #include @@ -35,13 +36,14 @@ namespace sgpem class SG_DLLEXPORT Statistics : public Singleton { - public: - - + public: virtual ~Statistics() = 0; static Statistics& get_instance(); - virtual std::vector get_process_statistics(const int& instant) const = 0; + virtual void calculateStatisticsAt(const int& instant) = 0; + + virtual std::vector get_process_statistics() const = 0; + virtual const SimulationStatistics* get_simulation_statistics() const = 0; protected: @@ -51,3 +53,5 @@ namespace sgpem } #endif + + diff --git a/src/backend/sgpemv2/thread_statistics.hh b/src/backend/sgpemv2/thread_statistics.hh new file mode 100644 index 0000000..3d3f668 --- /dev/null +++ b/src/backend/sgpemv2/thread_statistics.hh @@ -0,0 +1,57 @@ +// src/backend/thread_statistics.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef THREAD_STATISTICS_HH +#define THREAD_STATISTICS_HH 1 + +#include "config.h" + +#include +#include + +#include + + +namespace sgpem +{ + class ThreadStatistics : public SchedulableStatistics + { + public: + ~ThreadStatistics(); + + int get_execution_time() const =0; + int get_execution_progress() const =0; + int get_total_inactivity() const =0; + int get_response_time() const =0; + int get_turn_around() const =0; + int get_efficency() const =0; + int get_resource_usage_time() const =0; + int get_resource_waitings_time() const =0; + + const Thread* get_core() const =0; + + virtual int get_real_arrival_time() const =0; //useful for ProcessStatistics + + protected: + ThreadStatistics(); + }; +} + +#endif diff --git a/src/backend/simulation_statistics.cc b/src/backend/simulation_statistics.cc new file mode 100644 index 0000000..a0b36b5 --- /dev/null +++ b/src/backend/simulation_statistics.cc @@ -0,0 +1,31 @@ +// src/backend/simulation_statistics.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#include + +using namespace sgpem; + +SimulationStatistics::~SimulationStatistics() +{} + +SimulationStatistics::SimulationStatistics() +{} + + diff --git a/src/backend/statistics.cc b/src/backend/statistics.cc index 44641b0..1e0a42a 100755 --- a/src/backend/statistics.cc +++ b/src/backend/statistics.cc @@ -18,7 +18,7 @@ // along with SGPEMv2; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -#include "sgpemv2/statistics.hh" +#include #include "concrete_statistics.hh" // Do not include in header file: @@ -36,4 +36,9 @@ Statistics& Statistics::get_instance() { return Singleton::get_instance(); -} \ No newline at end of file +} + + + + + diff --git a/src/backend/thread_statistics.cc b/src/backend/thread_statistics.cc index f1dcff8..f685fd1 100644 --- a/src/backend/thread_statistics.cc +++ b/src/backend/thread_statistics.cc @@ -18,176 +18,16 @@ // along with SGPEMv2; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -#include "thread_statistics.hh" -#include "sgpemv2/simulation.hh" -#include "sgpemv2/history.hh" -#include "sgpemv2/environment.hh" -#include "sgpemv2/schedulable.hh" -#include "sgpemv2/process.hh" -#include "sgpemv2/thread.hh" -#include "sgpemv2/resource.hh" -#include "sgpemv2/request.hh" -#include -using namespace std; +#include + using namespace sgpem; -/** - The constructor executes all calculations examinating or only the Thread object - or the whole History - -*/ -ThreadStatistics::ThreadStatistics(const Thread* core, const int& instant): _core(core) +ThreadStatistics::ThreadStatistics() { - //initializations - _total_inactivity = 0; - _execution_time = 0; - _response_time = -1; - _real_arrival_time = -1; - _turn_around = 0; - _resource_usage_time = 0; - _resource_waitings_time = 0; - - bool iniziato = false; //useful for _response_time - - const History& hist = Simulation::get_instance().get_history(); //prendo la lista delle risorse - const map res = hist.get_environment_at(0).get_resources(); - - //****** iterate through HISTORY to retreive informations - for (int time=0; time < instant; time++) - { - const Environment& env = hist.get_environment_at(time); - const vector procs = env.get_processes(); - - //looks for the process that owns this thread - for (uint i_p=0; i_p < procs.size(); i_p++) - { - const vector threads = procs[i_p]->get_threads(); - //looks for the thread "core" - for (uint i_t = 0; i_t < threads.size(); i_t++) - { - if ( (*threads[i_t]) == (*core) ) //FOUND!! - { - if (threads[i_t]->get_state() == Schedulable::state_running) - { - iniziato = true; - if( _response_time == -1) //arrives and runs immediately - { - _response_time = 0; - _real_arrival_time = time - procs[i_p]->get_arrival_time() -1; - } - _execution_time++; - } - if (threads[i_t]->get_state() != Schedulable::state_future && - threads[i_t]->get_state() != Schedulable::state_terminated) - { - _turn_around++; - if (!iniziato && _response_time == -1) //arrives and doesn't run - { - _response_time = 0; - _real_arrival_time = time - procs[i_p]->get_arrival_time() -1; - } - } - if (threads[i_t]->get_state() == Schedulable::state_blocked - || threads[i_t]->get_state() == Schedulable::state_ready) - { - _total_inactivity++; - if (!iniziato && _response_time != -1) - _response_time++; - - if (threads[i_t]->get_state() == Schedulable::state_blocked) - _resource_waitings_time++; - } - } - } //threads - } //procs - - - //for each resource check requests at this istant: - //if the request of this thread is allocated then increase _resource_usage_time - Environment::Resources::const_iterator res_iter = res.begin(); - while(res_iter != res.end()) - { - Environment::resource_key_t key = (*res_iter).first; - vector req = env.get_request_queue(key); - for (uint i_r=0; i_r < req.size(); i_r++) - if( (*req[i_r]).get_request().get_thread() == (*core) && (*req[i_r]).get_state() == Request::state_allocated) - _resource_usage_time++; - - res_iter++; - } - - }//istants - - //set other variables - _execution_progress = (100*_execution_time)/core->get_total_cpu_time(); - if (_turn_around == 0) - _efficency = -1; - else - _efficency = (_execution_time*100)/_turn_around; } - ThreadStatistics::~ThreadStatistics() -{ +{ } -int -ThreadStatistics::get_execution_time() const -{ - return _execution_time; -} - -int -ThreadStatistics::get_execution_progress() const -{ - return _execution_progress; -} - -int -ThreadStatistics::get_total_inactivity() const -{ - return _total_inactivity; -} - -int -ThreadStatistics::get_response_time() const -{ - return _response_time; -} - -int -ThreadStatistics::get_turn_around() const -{ - return _turn_around; -} - -int -ThreadStatistics::get_efficency() const -{ - return _efficency; -} - -int -ThreadStatistics::get_resource_usage_time() const -{ - return _resource_usage_time; -} - -int -ThreadStatistics::get_resource_waitings_time() const -{ - return _resource_waitings_time; -} - -int -ThreadStatistics::get_real_arrival_time() const -{ - return _real_arrival_time; -} - -const Thread* -ThreadStatistics::get_core() const -{ - return _core; -} diff --git a/src/gui_builder.cc b/src/gui_builder.cc index d4336de..b0604a8 100644 --- a/src/gui_builder.cc +++ b/src/gui_builder.cc @@ -616,6 +616,10 @@ GuiBuilder::GuiBuilder(const std::string& gladefile) _holt_container.set_keep_above(); _holt_container.get_holt_widget().set_show_threads(_show_threads); _holt_container.show(); + + // Statistics container window + _statistics_container.set_keep_above(); + _statistics_container.show(); } diff --git a/src/gui_builder.hh b/src/gui_builder.hh index e5a5a31..7ccfa42 100644 --- a/src/gui_builder.hh +++ b/src/gui_builder.hh @@ -23,6 +23,7 @@ #include "config.h" #include "holt_container_window.hh" +#include "statistics_container_window.hh" #include "simulation_widget.hh" #include @@ -80,6 +81,7 @@ namespace sgpem std::string _filename; HoltContainerWindow _holt_container; + StatisticsContainerWindow _statistics_container; SimulationWidget* _simulation_widget; bool _show_threads; diff --git a/src/holt_container_window.cc b/src/holt_container_window.cc index 1d9364d..847f386 100644 --- a/src/holt_container_window.cc +++ b/src/holt_container_window.cc @@ -1,3 +1,23 @@ +// src/holt_container_window.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + #include "holt_container_window.hh" using namespace sgpem; diff --git a/src/holt_container_window.hh b/src/holt_container_window.hh index 68fbe04..c7f87b0 100644 --- a/src/holt_container_window.hh +++ b/src/holt_container_window.hh @@ -1,4 +1,4 @@ -// src/simulation_widget.hh - Copyright 2005, 2006, University +// src/holt_container_window.hh - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // diff --git a/src/holt_widget.cc b/src/holt_widget.cc index 4d72817..84f3423 100644 --- a/src/holt_widget.cc +++ b/src/holt_widget.cc @@ -1,4 +1,4 @@ -// src/simulation_widget.cc - Copyright 2005, 2006, University +// src/holt_widget.cc - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // diff --git a/src/holt_widget.hh b/src/holt_widget.hh index 957f7d7..ad3d221 100644 --- a/src/holt_widget.hh +++ b/src/holt_widget.hh @@ -1,4 +1,4 @@ -// src/simulation_widget.hh - Copyright 2005, 2006, University +// src/holt_widget.hh - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // diff --git a/src/schedulables_statistics_widget.cc b/src/schedulables_statistics_widget.cc new file mode 100644 index 0000000..0594607 --- /dev/null +++ b/src/schedulables_statistics_widget.cc @@ -0,0 +1,321 @@ +// src/schedulables_statistics_widget.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +#include "gettext.h" + + +#include "schedulables_statistics_widget.hh" +#include +#include +#include + +#include +#include + +using namespace sgpem; +using namespace std; + +using namespace Gtk; +using namespace Glib; + + +TabularSchedulableStatisticsWidget::TabularSchedulableStatisticsWidget() +{ + + _show_runs = _show_perc = _show_inactive = _show_turn = + _show_resp = _show_effic = + _show_ris_usage = _show_ris_block = true; + + //insert columns + _columns.add(_col_name); + _columns.add(_col_runs); + _columns.add(_col_perc); + _columns.add(_col_inactive); + _columns.add(_col_turn); + _columns.add(_col_resp); + _columns.add(_col_effic); + _columns.add(_col_ris_usage); + _columns.add(_col_ris_block); + + _model = TreeStore::create(_columns); + set_model(_model); + + //show only columns chosen by the user + update_columns(); + + set_headers_visible(true); + + // Register this HistoryObserver: + Simulation::get_instance().get_history().attach(*this); +} + +TabularSchedulableStatisticsWidget::~TabularSchedulableStatisticsWidget() +{ + Simulation::get_instance().get_history().detach(*this); +} + + +void +TabularSchedulableStatisticsWidget::update(const History& changed_history) +{ + _model->clear(); + + Statistics::get_instance().calculateStatisticsAt(changed_history.get_front()); + vector p_stats = Statistics::get_instance().get_process_statistics(); + + for(unsigned int i_p = 0; i_p < p_stats.size(); i_p++) + { + TreeModel::Row riga_P = *(_model->append()); + + riga_P[_col_name] = p_stats[i_p]->get_core()->get_name(); + riga_P[_col_runs] = p_stats[i_p]->get_execution_time(); + stringstream s1; s1 << p_stats[i_p]->get_execution_progress() << "%"; + riga_P[_col_perc] = Glib::ustring(s1.str()); + riga_P[_col_inactive]= p_stats[i_p]->get_total_inactivity(); + stringstream s2; + if (p_stats[i_p]->get_response_time() != -1) + s2 << p_stats[i_p]->get_response_time() << " (avg:" << p_stats[i_p]->get_average_response_time() << ")"; + else + s2 << "---"; + riga_P[_col_resp] = Glib::ustring(s2.str()); + riga_P[_col_turn] = p_stats[i_p]->get_turn_around(); + stringstream s3; + if (p_stats[i_p]->get_efficency() != -1) + s3 << p_stats[i_p]->get_efficency() << "%"; + else + s3 << "---"; + riga_P[_col_effic] = Glib::ustring(s3.str()); + riga_P[_col_ris_usage] = p_stats[i_p]->get_resource_usage_time(); + riga_P[_col_ris_block] = p_stats[i_p]->get_resource_waitings_time(); + + vector t_stats = p_stats[i_p]->get_threads_statistics(); + + for(unsigned int i_t = 0; i_t < t_stats.size(); i_t++) + { + TreeModel::Row riga_T = *(_model->append(riga_P.children())); + riga_T[_col_name] = t_stats[i_t]->get_core()->get_name(); + riga_T[_col_runs] = t_stats[i_t]->get_execution_time(); + stringstream s1; s1 << t_stats[i_t]->get_execution_progress() << "%"; + riga_T[_col_perc] = Glib::ustring(s1.str()); + riga_T[_col_inactive]= t_stats[i_t]->get_total_inactivity(); + stringstream s2; + if (t_stats[i_t]->get_response_time() != -1) + s2 << t_stats[i_t]->get_response_time(); + else + s2 << "---"; + riga_T[_col_resp] = Glib::ustring(s2.str()); + riga_T[_col_turn] = t_stats[i_t]->get_turn_around(); + stringstream s3; + if (t_stats[i_t]->get_efficency() != -1) + s3 <get_efficency() << "%"; + else + s3 << "---"; + riga_T[_col_effic] = Glib::ustring(s3.str()); + riga_T[_col_ris_usage] = t_stats[i_t]->get_resource_usage_time(); + riga_T[_col_ris_block] = t_stats[i_t]->get_resource_waitings_time(); + } + } + expand_all(); +} + + +void +TabularSchedulableStatisticsWidget::update_columns() +{ + remove_all_columns(); + + append_column(_("Schedulable"), _col_name); + + if (_show_runs) + append_column(_("Running"), _col_runs); + + if (_show_perc ) + append_column(_("Completed"), _col_perc); + + if (_show_inactive) + append_column(_("Inactivity"), _col_inactive); + + if (_show_turn) + append_column(_("Turn Around"), _col_turn); + + if (_show_resp) + append_column(_("Response"), _col_resp); + + //if (_show_turn) +// append_column(_("Turn Around"), _col_inactive); + + if (_show_effic) + append_column(_("Efficency"), _col_effic); + + if (_show_ris_usage) + append_column(_("Res. usage"), _col_ris_usage); + + if (_show_ris_block) + append_column(_("Res. block"), _col_ris_block); + + +} + +void +TabularSchedulableStatisticsWidget::set_show_runs(bool b) +{ + _show_runs = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_runs() const +{ + return _show_runs; +} + +void +TabularSchedulableStatisticsWidget::set_show_perc(bool b) +{ + _show_perc = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_perc() const +{ + return _show_perc; +} + +void +TabularSchedulableStatisticsWidget::set_show_inactive(bool b) +{ + _show_inactive = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_inactive() const +{ + return _show_inactive; +} + + +void +TabularSchedulableStatisticsWidget::set_show_turn_around(bool b) +{ + _show_turn = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_turn_around() const +{ + return _show_turn; +} + +void +TabularSchedulableStatisticsWidget::set_show_response(bool b) +{ + _show_resp = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_response() const +{ + return _show_resp; +} + +void +TabularSchedulableStatisticsWidget::set_show_efficency(bool b) +{ + _show_effic = b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_efficency() const +{ + return _show_effic; +} + +void +TabularSchedulableStatisticsWidget::set_show_resource_usage(bool b) +{ + _show_ris_usage= b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_resource_usage() const +{ + return _show_ris_usage; +} + +void +TabularSchedulableStatisticsWidget::set_show_resource_block(bool b) +{ + _show_ris_block= b; +} + +bool +TabularSchedulableStatisticsWidget::get_show_resource_block() const +{ + return _show_ris_block; +} + +/* +void +TabularSchedulableStatisticsWidget::draw_widget(cairo_t* ctx) +{ + cout << "\nTabularSchedulableStatisticsWidget::draw_widget"; + + + // draw text: T = n as title + + const History& hist = Simulation::get_instance().get_history(); + cairo_text_extents_t extents; + stringstream ss; + ss << "!CIAO MONDO!" ; + cairo_text_extents(ctx, ss.str().c_str(), &extents); + cairo_move_to(ctx, _draw_w/2 - extents.width/2.0, extents.height*2.0); + cairo_show_text(ctx, ss.str().c_str()); + + + //cairo_save(ctx); + //cairo_set_source(ctx, _running_process_gradient); + // cairo_matrix_init_scale(&matrix, 1.0, y); + // cairo_matrix_translate(&matrix, 0, -y); + //cairo_matrix_init_translate(&matrix, 0, -y); + //cairo_pattern_set_matrix (_running_process_gradient, &matrix); + cairo_set_source_rgba(ctx, 1,0,0,1); + cairo_rectangle(ctx, 0.5, 0.5, 10, 10); + cairo_fill(ctx); + + //cairo_restore(ctx); + //break; + +} + + +void +TabularSchedulableStatisticsWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height) +{ + cout << "\nHolt widget calc_drawing_size"; +} + +void +TabularSchedulableStatisticsWidget::calc_widget_size(size_t& width, size_t& height) +{ + cout << "\nHolt widget calc_widget_size"; + //width = height = 20; // default minimum size +} + +*/ \ No newline at end of file diff --git a/src/schedulables_statistics_widget.hh b/src/schedulables_statistics_widget.hh new file mode 100644 index 0000000..46511f9 --- /dev/null +++ b/src/schedulables_statistics_widget.hh @@ -0,0 +1,98 @@ +// src/schedulable_statistics_widget.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef SCHEDULABLE_STATISTICS_WIDGET_HH +#define SCHEDULABLE_STATISTICS_WIDGET_HH 1 + +#include "config.h" + +#include "cairo_widget.hh" +#include + +#include +#include + +namespace sgpem +{ + + + class TabularSchedulableStatisticsWidget : public HistoryObserver, public Gtk::TreeView + { + public: + TabularSchedulableStatisticsWidget(); + virtual ~TabularSchedulableStatisticsWidget(); + + void update(const History& changed_history); + + void set_show_runs(bool); + bool get_show_runs() const; + + void set_show_perc(bool); + bool get_show_perc() const; + + void set_show_inactive(bool); + bool get_show_inactive() const; + + void set_show_turn_around(bool); + bool get_show_turn_around() const; + + void set_show_response(bool); + bool get_show_response() const; + + void set_show_efficency(bool); + bool get_show_efficency() const; + + void set_show_resource_usage(bool); + bool get_show_resource_usage() const; + + void set_show_resource_block(bool); + bool get_show_resource_block() const; + + protected: + void update_columns(); + + bool _show_runs, //which info to show + _show_perc, + _show_inactive, + _show_turn, + _show_resp, + _show_effic, + _show_ris_usage, + _show_ris_block; + + Glib::RefPtr _model; //treeview stuffs + Gtk::TreeModelColumnRecord _columns; + + Gtk::TreeModelColumn _col_name; //all columns + Gtk::TreeModelColumn _col_runs; + Gtk::TreeModelColumn _col_perc; + Gtk::TreeModelColumn _col_inactive; + Gtk::TreeModelColumn _col_turn; + Gtk::TreeModelColumn _col_resp; + Gtk::TreeModelColumn _col_effic; + Gtk::TreeModelColumn _col_ris_usage; + Gtk::TreeModelColumn _col_ris_block; + + }; + +} //~ namespace sgpem + + +#endif diff --git a/src/simulation_widget.cc b/src/simulation_widget.cc index fbff192..034a99c 100644 --- a/src/simulation_widget.cc +++ b/src/simulation_widget.cc @@ -30,13 +30,6 @@ #include -//********************** PROVE di STATISTICS -#include -#include "backend/sgpemv2/statistics.hh" -#include "backend/thread_statistics.hh" -using namespace std; -//************************* - #ifndef NDEBUG #include #endif @@ -134,49 +127,7 @@ SimulationWidget::update(const History& changed_history ) _partial_redraw = false; // MOVED in calc_drawing_size(...) // count_elements(); - resize_redraw(); - - - - cout << "\n\n****** STATS BEGIN*******\n"; - - vector p_stats = Statistics::get_instance().get_process_statistics(changed_history.get_front()); - - cout << "\n INSTANT = " << (int)changed_history.get_front()-1 << "\n\n"; - - - for(int i_p = 0; i_p < p_stats.size(); i_p++) - { - cout << "\n\n== " << p_stats[i_p].get_core()->get_name().c_str() << - "\t\tRUN= " << p_stats[i_p].get_execution_time() << - "\tPERC= " << p_stats[i_p].get_execution_progress() << "%"<< - "\tTURN= " << p_stats[i_p].get_turn_around() << - "\tRISP= " << p_stats[i_p].get_response_time() << - "\t~RISP= " << p_stats[i_p].get_average_response_time() << - "\tEFF= " << p_stats[i_p].get_efficency() << "%" << - "\tINACTIVE= " << p_stats[i_p].get_total_inactivity() << - "\tRIS_USAGE= " << p_stats[i_p].get_resource_usage_time() << - "\tRIS_BLOCK= " << p_stats[i_p].get_resource_waitings_time() ; - - cout << "\n |"; - - vector t_stats = p_stats[i_p].get_threads_statistics(); - - for(int i_t = 0; i_t < t_stats.size(); i_t++) - cout << "\n |-- " << t_stats[i_t].get_core()->get_name().c_str() << - "\t\tRUN= " << t_stats[i_t].get_execution_time() << - "\tPERC= " << t_stats[i_t].get_execution_progress() << "%" << - "\tINACTIVE= " << t_stats[i_t].get_total_inactivity() << - "\tRISP= " << t_stats[i_t].get_response_time() << - "\tTURN= " << t_stats[i_t].get_turn_around() << - "\tEFF= " << t_stats[i_t].get_efficency() << "%" << - "\tRIS_USAGE= " << t_stats[i_t].get_resource_usage_time() << - "\tRIS_BLOCK= " << t_stats[i_t].get_resource_waitings_time(); - - } - - cout << "\n\n****** STATS END*******\n"; - + resize_redraw(); } diff --git a/src/statistics_container_window.cc b/src/statistics_container_window.cc new file mode 100644 index 0000000..936ee3f --- /dev/null +++ b/src/statistics_container_window.cc @@ -0,0 +1,64 @@ +// src/statistics_container_window.cc - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#include "statistics_container_window.hh" +#include + +using namespace sgpem; +using namespace std; + +StatisticsContainerWindow::StatisticsContainerWindow() +{ + // This just sets the title of our new window. + set_title(_("Simulation Statistics")); + _scrolled_tabular.add(_tabular_schedulables_statistics_widget); + add(_scrolled_tabular); + _scrolled_tabular.show(); + _tabular_schedulables_statistics_widget.show(); + + _scrolled_tabular.get_hscrollbar()->property_visible() = true; + _scrolled_tabular.get_vscrollbar()->property_visible() = true; + + //_scrolled_tabular.get_vscrollbar()->set_visible(true); + + /*cout << "\n\nSIIIIIIIIIIIIIIIIIIIII\n\n"; + if (_scrolled_tabular.get_vscrollbar_visible()) + cout << "\n\nSIIIIIIIIIIIIIIIIIIIII\n\n"; + else + cout << "\n\nNNNNNNNNNNNNNNNOOOOOOOOOOO\n\n"; + */ +} + +StatisticsContainerWindow::~StatisticsContainerWindow() +{ +} + +void +StatisticsContainerWindow::on_size_request(Gtk::Requisition* /* requisition */ ) +{ + +} + +TabularSchedulableStatisticsWidget& +StatisticsContainerWindow::get_tabular_schedulables_statistics_widget() +{ + return _tabular_schedulables_statistics_widget; +} + diff --git a/src/statistics_container_window.hh b/src/statistics_container_window.hh new file mode 100644 index 0000000..dadf807 --- /dev/null +++ b/src/statistics_container_window.hh @@ -0,0 +1,56 @@ +// src/statistics_container_window.hh - Copyright 2005, 2006, University +// of Padova, dept. of Pure and Applied +// Mathematics +// +// This file is part of SGPEMv2. +// +// This 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. +// +// SGPEMv2 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 SGPEMv2; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +#ifndef STATISTICS_CONTAINER_WINDOW_HH +#define STATISTICS_CONTAINER_WINDOW_HH 1 + +#include "config.h" +#include "gettext.h" + +#include +#include +#include + +#include +#include + +#include +#include "schedulables_statistics_widget.hh" + +namespace sgpem { + + + class StatisticsContainerWindow : public Gtk::Window + { + public: + StatisticsContainerWindow(); + virtual ~StatisticsContainerWindow(); + + TabularSchedulableStatisticsWidget& get_tabular_schedulables_statistics_widget(); + protected: + + virtual void on_size_request (Gtk::Requisition* requisition); + TabularSchedulableStatisticsWidget _tabular_schedulables_statistics_widget; + Gtk::ScrolledWindow _scrolled_tabular; + }; + +} // ~ namespace sgpem +#endif +