diff --git a/src/Makefile.am b/src/Makefile.am index 9817d5a..5e9f4e1 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -51,6 +51,7 @@ sgpemv2_SOURCES = \ graphical_terminal_io.cc \ main.cc \ main_window.cc \ + observer.cc \ parse_opts.cc \ start_gui.cc diff --git a/src/backend/Makefile.am b/src/backend/Makefile.am index eaeec84..6f3a047 100644 --- a/src/backend/Makefile.am +++ b/src/backend/Makefile.am @@ -49,18 +49,24 @@ libbackend_la_LDFLAGS = $(PYTHON_EXTRA_LDFLAGS) \ libbackend_la_SOURCES = \ history.cc \ observed_subject.cc \ + policy.cc \ + policy_parameters.cc \ process.cc \ schedulable.cc \ + schedulable_list.cc \ schedulable_status.cc \ - simulation_status.cc \ + scheduler.cc \ slice.cc noinst_HEADERS = \ history.hh \ observed_subject.hh \ + policy.hh \ + policy_parameters.hh \ process.hh \ schedulable.hh \ + schedulable_list.hh \ schedulable_status.hh \ - simulation_status.hh \ + scheduler.hh \ slice.hh diff --git a/src/backend/history.cc b/src/backend/history.cc index 3f764a0..0734993 100644 --- a/src/backend/history.cc +++ b/src/backend/history.cc @@ -26,56 +26,66 @@ using namespace memory; //History::instance; //static object History History::_instance(10); //dummy parameter - +/** + The constructor sets _total_time_elapsed to -1: this permits to insert the INITIAL STATUS + of the simulation which must begin at instant -1 and live for 1 instant. +*/ History::History(int) //private constructor. The parameter is discarded - :_total_time_elapsed(0) + :_total_time_elapsed(-1) {} History& -History::getInstance() +History::get_instance() { return _instance; } -/* +/** Returns a pointer to a copy of the SchedulableStatus object relative to this instant. - It can be NULL if time is out of range or if the SimulationStatus object relative to - this instant has no running entities. + It can be NULL if time is out of range or if there are no running entities in the associated + SchedulableList */ smart_ptr -History::get_scheduled_at(int time) +History::get_scheduled_at(int time) const { if (time >= _total_time_elapsed || time < 0) //out of range return smart_ptr(NULL); - return get_simulation_status_at(time)->get_running(); + //look for a runing entity + smart_ptr p = get_simulation_status_at(time); + + for (int i = 0; i < p->size(); i++) + if (p->get_item_at(i)->get_state() == SchedulableStatus::state_running) + return smart_ptr(new SchedulableStatus(*(p->get_item_at(i)))); + + return smart_ptr(NULL); } /** Returns a pointer to a copy of the SimulationStatus object relative to this instant or NULL if time is out of range. */ -smart_ptr -History::get_simulation_status_at(int time) +smart_ptr +History::get_simulation_status_at(int time) const { - if (time >= _total_time_elapsed || time < 0) //out of range - return smart_ptr(NULL); + if (time > _total_time_elapsed || time < 0) //out of range + return smart_ptr(NULL); - int trascorso = 0; - for(vector::iterator i=_slices.begin(); i < _slices.end(); i++) - if (time < trascorso + i->get_duration()) //FOUND!! - return smart_ptr(new SimulationStatus(i->get_simulation_status())); - else //Go on... - trascorso += i->get_duration(); + int trascorso = -1; + for(vector::const_iterator i=_slices.begin(); i < _slices.end(); i++) + if (time <= trascorso + i->get_duration()) //FOUND!! + return smart_ptr(new SchedulableList(*i->get_simulation_status())); + else //Go on... + trascorso += i->get_duration(); - //never reached - return smart_ptr(NULL); + //never reached if all slices are CONTIGUOUS (ans THIS shoul be!!)!!! + return smart_ptr(NULL); } int -History::get_current_time() +History::get_current_time() const { return _total_time_elapsed; } @@ -85,10 +95,11 @@ History::get_current_time() Calls the method notify() in quality of ObservedSubject, updating all observers. */ void -History::enqueue_slice(SimulationStatus status) +History::enqueue_slice(const SchedulableList& status) { - if(_slices.size() == 0){ - _slices.push_back(Slice(0, 1, status)); + if(_slices.size() == 0) + { + _slices.push_back(Slice(-1, 1, status)); _total_time_elapsed = 1; notify(); return; @@ -96,10 +107,10 @@ History::enqueue_slice(SimulationStatus status) //check the last slice Slice& last = _slices[_slices.size()-1]; - if (last.get_simulation_status() == status) //increments the duration by ONE unit - { - last.set_duration(last.get_duration()+1); - } + if (last.get_simulation_status()->has_same_objects(status)) //increments the duration by ONE unit + { + last.set_duration(last.get_duration()+1); + } else //insert a new slice CONTIGUOUS to the last one { _slices.push_back(Slice(last.get_started_at() + last.get_duration(), 1, status)); @@ -109,18 +120,26 @@ History::enqueue_slice(SimulationStatus status) } /** - Removes all the informations about the simulation following the specified instant. + Removes all the informations about the simulation following the specified instant. + + Ex. truncate_at(0); removes all scheduled slices + Ex. truncate_at(-1); removes all scheduled slices and the initial status */ void History::truncate_at(int instant) { - //reach the instant - vector::iterator i = _slices.begin(); - for (int k=0; k < instant; k++) - i++; - //replaces the current vector with the "trimmed" one. - _slices = vector(_slices.begin(),i); - _total_time_elapsed = instant; + vector::iterator i = _slices.begin(); + //reach the instant + while (i != _slices.end()) + if (i->get_started_at() < instant) + i++; + else + { + //replaces the current vector with the "trimmed" one. + _slices = vector(_slices.begin(),i); + _total_time_elapsed = instant; + return; + } } diff --git a/src/backend/history.hh b/src/backend/history.hh index 8dd0969..f56affa 100644 --- a/src/backend/history.hh +++ b/src/backend/history.hh @@ -28,7 +28,7 @@ #include "slice.hh" #include "observed_subject.hh" -#include "simulation_status.hh" +#include "schedulable_list.hh" #include "schedulable_status.hh" #include "../templates/smartp.hh" @@ -47,16 +47,17 @@ namespace sgpem */ class History; - class SG_DLLEXPORT History : public ObservedSubject { + class SG_DLLEXPORT History : public ObservedSubject + { public: - memory::smart_ptr get_scheduled_at(int time); - memory::smart_ptr get_simulation_status_at(int time); - int get_current_time(); - void enqueue_slice(sgpem::SimulationStatus status); - void truncate_at(int instant); + memory::smart_ptr get_scheduled_at(int time) const; + memory::smart_ptr get_simulation_status_at(int time) const; + int get_current_time() const; + void enqueue_slice(const sgpem::SchedulableList& status); + void truncate_at(int instant); - static History& getInstance(); + static History& get_instance(); private: History(int); //private constructor. The parameter is discarded diff --git a/src/backend/policy.cc b/src/backend/policy.cc new file mode 100644 index 0000000..e73a891 --- /dev/null +++ b/src/backend/policy.cc @@ -0,0 +1,25 @@ +// src/backend/policy.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 "policy.hh" +using namespace std; +using namespace sgpem; +using namespace memory; + diff --git a/src/backend/policy.hh b/src/backend/policy.hh new file mode 100644 index 0000000..c5976d3 --- /dev/null +++ b/src/backend/policy.hh @@ -0,0 +1,51 @@ +// src/backend/policy.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 POLICY_HH +#define POLICY_HH 1 + +#include "config.h" +#include "scheduler.hh" + +namespace sgpem +{ + + class Policy; + + /** \brief + e' una Strategy che rappresenta un algoritmo di scheduling che implementa una politica + di scheduling. + */ + class SG_DLLEXPORT Policy + { + public: + void sort_queue(sgpem::Scheduler::event) {} + bool is_pre_emptive() {return true;} + int get_time_slice() {return 2;} + + private: + + }; + +}//~ namespace sgpem + + + +#endif \ No newline at end of file diff --git a/src/backend/policy_parameters.cc b/src/backend/policy_parameters.cc new file mode 100644 index 0000000..8990d38 --- /dev/null +++ b/src/backend/policy_parameters.cc @@ -0,0 +1,25 @@ +// src/backend/policy_parameters.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 "policy_parameters.hh" +using namespace std; +using namespace sgpem; + + diff --git a/src/backend/policy_parameters.hh b/src/backend/policy_parameters.hh new file mode 100644 index 0000000..056ce49 --- /dev/null +++ b/src/backend/policy_parameters.hh @@ -0,0 +1,62 @@ +// src/backend/policy_parameters.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 POLICY_PARAMETERS_HH +#define POLICY_PARAMETERS_HH 1 + +#include "config.h" + + + +namespace sgpem +{ + + class PolicyParameters; + + /** \brief + + */ + class SG_DLLEXPORT PolicyParameters + { + public: + template + class Parameter; + + + private: + + }; + + template + class PolicyParameters::Parameter + { + public: + + + private: + }; + + + +}//~ namespace sgpem + + + +#endif \ No newline at end of file diff --git a/src/backend/schedulable.hh b/src/backend/schedulable.hh index 019715a..24bf844 100644 --- a/src/backend/schedulable.hh +++ b/src/backend/schedulable.hh @@ -42,11 +42,11 @@ namespace sgpem Schedulable(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority); virtual ~Schedulable() = 0; - virtual unsigned int get_arrival_time() const; + virtual unsigned int get_arrival_time() const; unsigned int get_total_cpu_time() const; - int get_priority() const; - Glib::ustring get_name() const; - virtual Glib::ustring get_type() const = 0; + int get_priority() const; + Glib::ustring get_name() const; + virtual Glib::ustring get_type() const = 0; private: Glib::ustring _name; diff --git a/src/backend/schedulable_list.cc b/src/backend/schedulable_list.cc new file mode 100644 index 0000000..1bb755c --- /dev/null +++ b/src/backend/schedulable_list.cc @@ -0,0 +1,200 @@ +// src/frontend/schedulable_list.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 "schedulable_list.hh" + +using namespace sgpem; +using namespace std; +using namespace memory; + + +SchedulableList::SchedulableList() +{ +} + +/** + Returns a pointer to the first element. If the queue is empty the NULL pointer will + be returned. + + DON'T call delete on the returned pointer! Its destruction is managed by the queue. + */ + +SchedulableStatus* +SchedulableList::top() +{ + if (_list.size() == 0) + return NULL; + return &_list.front(); +} + +/** + Returns a pointer to the last element. If the queue is empty the NULL pointer will + be returned. + + DON'T call delete on the returned pointer! Its destruction is managed by the queue. +*/ + +SchedulableStatus* +SchedulableList::bottom() +{ + if (_list.size() == 0) + return NULL; + return &_list.back(); +} + +/** + Returns a pointer to the element at position "where". If the queue is empty or "where" is + out of rangethe NULL pointer will be returned. + + DON'T call delete on the returned pointer! Its destruction is managed by the queue. + */ +SchedulableStatus* +SchedulableList::get_item_at(const uint& where) +{ + if (_list.size() == 0 || where >= _list.size()) + return NULL; + + list::iterator i = _list.begin(); + for (uint f=0; f < where; f++) + i++; + return &(*i); +} + +const SchedulableStatus* +SchedulableList::get_item_at(const uint& where) const +{ + if (_list.size() == 0 || where >= _list.size()) + return NULL; + + list::const_iterator i = _list.begin(); + for (uint f=0; f < where; f++) + i++; + return &(*i); +} + +/** + Returns the number of elements inserted into the queue. +*/ + +uint +SchedulableList::size() const +{ + return _list.size(); +} + + +void +SchedulableList::add_at_bottom(const SchedulableStatus& ss) +{ + _list.push_back(ss); +} + +void +SchedulableList::add_at_top(const SchedulableStatus& ss) +{ + _list.push_front(ss); +} + +/** + Removes an element from the list. Returns a smart pointer a copy of it or to NULL if + "position" is out of range. + + Ex. remove(0); removes the top of the list + Ex. remove(size()-1) removes the bottom of the list +*/ +smart_ptr +SchedulableList::remove(const uint& position) +{ + if (_list.size() == 0 || position >= _list.size()) + return smart_ptr(NULL); + + //creates a copy of the first element + smart_ptr sm = new SchedulableStatus(*top()); + //pops the first element + _list.pop_front(); + //returns the copy + return sm; +} + +/** + Switches two elements in the queue. Returns FALSE if one of the indexes is out of range. +*/ +bool +SchedulableList::insert_at(const uint& which, const uint& where) +{ + //out of range + if (which >= _list.size() || where >= _list.size()) + return false; + //nothing to do + if (where == which) + return true; + + list::iterator i_where = _list.begin(); + list::iterator i_which = _list.begin(); + for (uint f=0; f < where; f++) + i_where++; + for (uint f=0; f < which; f++) + i_which++; + + //save the one to replace + SchedulableStatus temp = *i_where; + //replace them + *i_where = *i_which; + *i_which = temp; + + return true; +} +/** + Removes all elements +*/ + +void +SchedulableList::clear() +{ + _list.clear(); +} + + +/** + \brief Returns TRUE if the two objects have the same SchedulableStatus objects in the same order. +*/ +bool +SchedulableList::operator==(const SchedulableList& dx) const +{ + return _list == dx._list; +} + + +/** + \brief Returns TRUE if the two objects have the same SchedulableStatus objects with NO ORDER IMPORTANCE. + */ +bool +SchedulableList::has_same_objects(const SchedulableList& dx) const +{ + if (_list.size() != dx._list.size()) + return false; + + //check if dx has ALL and ONLY the elements holded by _list with no order importance + for(list::const_iterator f=_list.begin(); f != _list.end(); f++) + if (find(dx._list.begin(), dx._list.end(), *f) == dx._list.end()) //element NOT found!! + return false; + + return true; +} diff --git a/src/backend/schedulable_list.hh b/src/backend/schedulable_list.hh new file mode 100644 index 0000000..e52162f --- /dev/null +++ b/src/backend/schedulable_list.hh @@ -0,0 +1,65 @@ +// src/backend/schedulable_list.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_LIST_HH +#define SCHEDULABLE_LIST_HH 1 + +#include "config.h" + +#include + +#include "schedulable_status.hh" +#include "../templates/smartp.hh" + + +namespace sgpem +{ + + class SchedulableList; + + + + class SG_DLLEXPORT SchedulableList + { + public: + SchedulableList(); + bool operator==(const SchedulableList&) const; + bool has_same_objects(const SchedulableList& dx) const; + + sgpem::SchedulableStatus* top(); + sgpem::SchedulableStatus* bottom(); + void add_at_bottom(const sgpem::SchedulableStatus&); + void add_at_top(const sgpem::SchedulableStatus&); + memory::smart_ptr remove(const uint& position); + bool insert_at(const uint&, const uint&); + uint size() const; + SchedulableStatus* get_item_at(const uint&); + const SchedulableStatus* get_item_at(const uint&) const; + void clear(); + + private: + + std::list _list; + }; + +}//~ namespace sgpem + +#endif //SCHEDULABLE_LIST_HH + diff --git a/src/backend/schedulable_status.cc b/src/backend/schedulable_status.cc index 86a349f..d2ebf22 100644 --- a/src/backend/schedulable_status.cc +++ b/src/backend/schedulable_status.cc @@ -1,4 +1,4 @@ -// src/backend/schedulableStatus.cc - Copyright 2005, 2006, University +// src/backend/schedulable_status.cc - Copyright 2005, 2006, University // of Padova, dept. of Pure and Applied // Mathematics // diff --git a/src/backend/scheduler.cc b/src/backend/scheduler.cc new file mode 100644 index 0000000..a61d51c --- /dev/null +++ b/src/backend/scheduler.cc @@ -0,0 +1,151 @@ +// src/backend/scheduler.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 "policy.hh" +#include "scheduler.hh" +using namespace std; +using namespace sgpem; +using namespace memory; + +//static object +Scheduler Scheduler::_instance(10); //dummy parameter + +/** + +*/ +Scheduler::Scheduler(int) //private constructor. The parameter is discarded +{} + +Scheduler& +Scheduler::get_instance() +{ + return _instance; +} + +SchedulableList* +Scheduler::get_ready_queue() +{ + return &_ready_queue; +} + +/** \note E' fondamentale che questo metodo memorizzi localmente qualora la politica + attuale sia a prerilascio o meno, e la durata del quanto di tempo, in quanto la politica + e' libera di variare questi parametri a piacere durante l'esecuzione della simulazione +*/ +void +Scheduler::reset_status() +{ + _ready_queue.clear(); + History::get_instance().truncate_at(0); + // restore the policy +} + + +void +Scheduler::step_forward() +{ + History& h = History::get_instance(); + //****************** + //check for arrivals and prepare the queue + //****************** + smart_ptr initial = h.get_simulation_status_at(h.get_current_time()); + _ready_queue.clear(); + + //adds running schedulable + smart_ptr running_ptr = h.get_scheduled_at(h.get_current_time()); + if (running_ptr) + _ready_queue.add_at_top(*running_ptr); + + //adds each new ready schedulable and sorts the queue + for(uint i=0; i < initial->size(); i++) + if (initial->get_item_at(i)->get_state() == SchedulableStatus::state_ready + && initial->get_item_at(i)->get_schedulable()->get_arrival_time() == h.get_current_time()) + { + _ready_queue.add_at_bottom(*initial->get_item_at(i)); + + //pops the running schedulable only if the policy is not preemptive + if (_policy->is_pre_emptive() == false && running_ptr) + _ready_queue.remove(0); + + // Sort the queue + _policy->sort_queue(event_schedulable_arrival); + + //restore the old running schedulable + if (_policy->is_pre_emptive() == false && running_ptr) + _ready_queue.add_at_top(*running_ptr); + } + + //**************** + // Check for termination + //**************** + + if (running_ptr && running_ptr->get_cpu_time_left() == 0) + { + //there was a running schedulable and it's terminated. Remove it! + for(uint i=0; i < _ready_queue.size(); i++) + if (*_ready_queue.get_item_at(i) == *running_ptr) + { + _ready_queue.remove(i); + break; + } + + //IF _ready_queue.size() == 0 sort_queue(...) is called but has no effect!! + _policy->sort_queue(event_schedulable_termination); + } + + //***************** + // Check for time slice + //***************** + if (_policy->get_time_slice() != numeric_limits::max()) //time-slice + _policy->sort_queue(event_end_time_slice); + + //****************** + // Create the final list of schedulable + //****************** + + SchedulableList final = _ready_queue; + + if (final.size() != 0) + //the firs element IS the running one (if != *running_ptr then there is a CONTEXT SWICH) + final.get_item_at(0)->set_state(SchedulableStatus::state_running); + + //all the others are ready + for (uint i = 1; i < final.size(); i++) + if (final.get_item_at(i)->get_state() == SchedulableStatus::state_running) + final.get_item_at(i)->set_state(SchedulableStatus::state_ready); + + //append blocked, future, terminated and the old running schedulables + for (uint i = 0; i < initial->size(); i++) + if(initial->get_item_at(i)->get_state() == SchedulableStatus::state_blocked + || initial->get_item_at(i)->get_state() == SchedulableStatus::state_future + || initial->get_item_at(i)->get_state() == SchedulableStatus::state_terminated + || (initial->get_item_at(i)->get_state() == SchedulableStatus::state_ready + && initial->get_item_at(i)->get_schedulable()->get_arrival_time() != h.get_current_time()) ) + final.add_at_bottom(*initial->get_item_at(i)); + + h.enqueue_slice(final); +} + + + + + + + diff --git a/src/backend/scheduler.hh b/src/backend/scheduler.hh new file mode 100644 index 0000000..a341441 --- /dev/null +++ b/src/backend/scheduler.hh @@ -0,0 +1,73 @@ +// src/backend/scheduler.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 SCHEDULER_HH +#define SCHEDULER_HH 1 +namespace sgpem +{ + class Policy; +} + +#include "config.h" + +#include + + +#include "observed_subject.hh" +#include "history.hh" +#include "schedulable_list.hh" + +namespace sgpem +{ + class Scheduler; + + /** \brief + + */ + + class SG_DLLEXPORT Scheduler : public ObservedSubject + { + public: + enum event + { + event_schedulable_arrival, + event_schedulable_termination, + event_end_time_slice + }; + + static Scheduler& get_instance(); + SchedulableList* get_ready_queue(); + void reset_status(); + void step_forward(); + + private: + Scheduler(int); //private constructor. The parameter is discarded + static Scheduler _instance; + SchedulableList _ready_queue; + Policy* _policy; + }; + +}//~ namespace sgpem + +#endif //SCHEDULER_HH + + + + diff --git a/src/backend/simulation_status.cc b/src/backend/simulation_status.cc deleted file mode 100644 index 61e609e..0000000 --- a/src/backend/simulation_status.cc +++ /dev/null @@ -1,95 +0,0 @@ -// src/backend/simulationStatus.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 "simulation_status.hh" -using namespace sgpem; -using namespace std; -using namespace memory; - -/** \brief Creates the SimulationStatus object with no SchedulableStatus object - - */ -SimulationStatus::SimulationStatus() -{ -} - -SimulationStatus::SimulationStatus(const SimulationStatus& dx) - :_set(dx._set) -{ -} - - - -/** \brief Adds a SchedulableStatus which represents a running Schedulable object. - - Adds a SchedulableStatus which represents a running Schedulable object. - Note that a copy of SchedulableStatus will be created -*/ -void -SimulationStatus::set_running(SchedulableStatus entity) -{ - if (entity.get_state() != SchedulableStatus::state_running) - entity.set_state(SchedulableStatus::state_running); - _set.push_back(entity); -} - -/** \brief Looks for a running Schedulable object and returns ist state. - Looks for a running Schedulable object and returns its state. There can be only - one running schedulable object. If no running schedulable object is found will be returned - the NULL pointer. -*/ - -smart_ptr -SimulationStatus::get_running() -{ - for (list::iterator f=_set.begin(); f != _set.end(); f++) - if (f->get_state() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext - return smart_ptr(new SchedulableStatus(*f)); - } - return smart_ptr(NULL); -} - -smart_ptr -SimulationStatus::get_running() const -{ - for (list::const_iterator f=_set.begin(); f != _set.end(); f++) - if (f->get_state() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext - return smart_ptr(new SchedulableStatus(*f)); - } - return smart_ptr(NULL); //NOT FOUND RUNNING ENTITIES -} - - -/** - \brief Returns TRUE if the two objects have the same SchedulableStatus objects -*/ -bool -SimulationStatus::operator==(const SimulationStatus& dx) const -{ - if (_set.size() != dx._set.size()) - return false; - - //check if dx has ALL and ONLY the elements holded by _set with no order importance - for(list::const_iterator f=_set.begin(); f != _set.end(); f++) - if (find(dx._set.begin(), dx._set.end(), *f) == dx._set.end()) //element NOT found!! - return false; - - return true; -} diff --git a/src/backend/simulation_status.hh b/src/backend/simulation_status.hh deleted file mode 100644 index 8b1f141..0000000 --- a/src/backend/simulation_status.hh +++ /dev/null @@ -1,61 +0,0 @@ -// src/backend/simulationStatus.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 SIMULATIONSTATUS_HH -#define SIMULATIONSTATUS_HH 1 - -#include "config.h" -#include - -#include "schedulable_status.hh" -#include "../templates/smartp.hh" - -namespace sgpem -{ - class SimulationStatus; - - /** \brief Keeps informatios about the configuration of the simulation - - Keeps informatios about the configuration of the simulation: which process is - running and other infos (since M02+) - */ - - class SG_DLLEXPORT SimulationStatus - { - public: - SimulationStatus(); - SimulationStatus(const SimulationStatus&); - - bool operator==(const SimulationStatus&) const; - - //this method isn't const because it returns a pointer which CAN alter the object! - memory::smart_ptr get_running(); - memory::smart_ptr get_running() const; - void set_running(SchedulableStatus); - - private: - //I used a list instead of a vector because this one could reallocate the internal elements - //making pointers returned by getRunning() point to nothing! SEGMENTATION-FAULT :-O - std::list _set; - }; - -} - -#endif diff --git a/src/backend/slice.cc b/src/backend/slice.cc index 4ecb93f..017097c 100644 --- a/src/backend/slice.cc +++ b/src/backend/slice.cc @@ -23,15 +23,15 @@ using namespace sgpem; using namespace std; -Slice::Slice(const int& start, const int& duration, const SimulationStatus& status) +Slice::Slice(const int& start, const int& duration, const SchedulableList& status) : _ref(status), _started_at(start), _duration(duration) { } -SimulationStatus& -Slice::get_simulation_status() +const SchedulableList* +Slice::get_simulation_status() const { - return _ref; + return &_ref; } int diff --git a/src/backend/slice.hh b/src/backend/slice.hh index bb59b72..8b64d4e 100644 --- a/src/backend/slice.hh +++ b/src/backend/slice.hh @@ -23,7 +23,7 @@ #include "config.h" -#include "simulation_status.hh" +#include "schedulable_list.hh" namespace sgpem { @@ -39,15 +39,15 @@ namespace sgpem class SG_DLLEXPORT Slice { public: - Slice(const int& start, const int& duration, const SimulationStatus& status); + Slice(const int& start, const int& duration, const SchedulableList& status); - SimulationStatus& get_simulation_status(); + const SchedulableList* get_simulation_status() const; int get_started_at() const; int get_duration() const; void set_duration(const int&); private: - SimulationStatus _ref; + SchedulableList _ref; int _started_at; int _duration; }; diff --git a/src/main.cc b/src/main.cc index a788727..5d814d7 100644 --- a/src/main.cc +++ b/src/main.cc @@ -27,10 +27,10 @@ #include "templates/smartp.hh" #include "backend/history.hh" -#include "backend/slice.hh" #include "backend/schedulable.hh" +#include "backend/schedulable_list.hh" #include "backend/schedulable_status.hh" -#include "backend/simulation_status.hh" +#include "backend/slice.hh" #include "backend/process.hh" #include @@ -68,32 +68,45 @@ main(int argc, char* argv[]) Process p1("P1", 0,10,1); Process p2("P2", 0,30,2); Process p3("P3", 5,15,3); + Process p4("P4", 6,5,3); + Process p5("P5", 1,10,3); + Process p6("P6", 10,2,1); - SchedulableStatus ss1(p1); + SchedulableStatus ss1(p1); ss1.set_state(SchedulableStatus::state_running); SchedulableStatus ss2(p2); SchedulableStatus ss3(p3); + SchedulableStatus ss4(p4); ss4.set_state(SchedulableStatus::state_running); + SchedulableStatus ss5(p5); + SchedulableStatus ss6(p6); - SimulationStatus sim1; sim1.set_running(p1); - SimulationStatus sim2; sim2.set_running(p2); - SimulationStatus sim3; sim3.set_running(p3); +// SimulationStatus sim1; sim1.set_running(p1); - History h(History::getInstance()); + //************** TEST HISTORY - h.enqueue_slice(sim1); - h.enqueue_slice(sim1); - h.enqueue_slice(sim2); - h.enqueue_slice(sim1); - h.enqueue_slice(sim2); - h.enqueue_slice(sim1); - h.enqueue_slice(sim2); - h.enqueue_slice(sim3); - h.enqueue_slice(sim3); - h.enqueue_slice(sim1); - h.enqueue_slice(sim3); - h.enqueue_slice(sim1); + SchedulableList l1; + l1.add_at_top(ss1); l1.add_at_top(ss2); l1.add_at_top(ss3); - h.truncate_at(3); + SchedulableList l2; + l2.add_at_top(ss4); l2.add_at_top(ss5); l2.add_at_top(ss6); + + History h(History::get_instance()); + h.enqueue_slice(l1); //stato iniziale + h.enqueue_slice(l2); + smart_ptr quale; + + quale = h.get_simulation_status_at(0); //stato iniziale + + cout << quale->get_item_at(0)->get_schedulable()->get_name(); + smart_ptr quale2 = h.get_scheduled_at(1); + cout << quale2->get_schedulable()->get_name(); + + h.truncate_at(0); + quale = h.get_simulation_status_at(0); //stato iniziale + + cout << bool(quale) << " " << quale->get_item_at(0)->get_schedulable()->get_name(); + + /* smart_ptr quale; quale = h.get_simulation_status_at(0); @@ -112,8 +125,23 @@ main(int argc, char* argv[]) if (quale2) cout << "\n" << quale2->get_schedulable()->get_name(); else cout << "NO"; quale2 = h.get_scheduled_at(2); if (quale2) cout << "\n" << quale2->get_schedulable()->get_name(); else cout << "NO"; + */ + //************** TEST QUEUE + cout << "\n\nTEST QUEUE\n"; + /* SchedulableQueue sq; + sq.add_at_top(ss1); + sq.add_at_top(ss2); + sq.add_at_bottom(ss3); + cout << sq.get_item_at(0)->get_schedulable()->get_name() << "\n"; + cout << sq.get_item_at(1)->get_schedulable()->get_name() << "\n"; + cout << sq.get_item_at(2)->get_schedulable()->get_name() << "\n"; + sq.insert_at(0,2); + cout << sq.get_item_at(0)->get_schedulable()->get_name() << "\n"; + cout << sq.get_item_at(1)->get_schedulable()->get_name() << "\n"; + cout << sq.get_item_at(2)->get_schedulable()->get_name() << "\n"; + */ cout << "\n\n"; return 0; } diff --git a/src/observer.cc b/src/observer.cc new file mode 100644 index 0000000..0a50493 --- /dev/null +++ b/src/observer.cc @@ -0,0 +1,31 @@ +// src/frontend/observer.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 "observer.hh" + +using namespace sgpem; + +Observer::Observer() +{ +} + +Observer::~Observer() +{ +} diff --git a/src/observer.hh b/src/observer.hh index 95d428c..fa784b1 100644 --- a/src/observer.hh +++ b/src/observer.hh @@ -37,9 +37,10 @@ namespace sgpem class SG_DLLEXPORT Observer { public: - virtual ~Observer() = 0; + Observer(); + virtual ~Observer() = 0; - virtual void update(); + virtual void update() =0; private: };