matteo/sgpemv2
matteo
/
sgpemv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- fixed a number of bugs 

- added dummy_policy written in C++
- the interpreter is now finished (hopefully)


git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@366 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
fpaparel 2006-02-21 11:09:55 +00:00
parent ea70e2f092
commit 4482b98df7
17 changed files with 230 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/backend/history.cc
View File

@ -47,41 +47,41 @@ History::get_instance()
It can be NULL if time is out of range or if there are no running entities in the associated
SchedulableList
*/
smart_ptr<const SchedulableStatus>
smart_ptr<SchedulableStatus>
History::get_scheduled_at(int time) const
{
if (time >= _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SchedulableStatus>(NULL);
if (time > _total_time_elapsed || time < 0) //out of range
return smart_ptr<SchedulableStatus>(NULL);
//look for a runing entity
smart_ptr<const SchedulableList> p = get_simulation_status_at(time);
smart_ptr<SchedulableList> p = get_simulation_status_at(time);
for (uint i = 0; i < p->size(); i++)
if (p->get_item_at(i)->get_state() == SchedulableStatus::state_running)
return smart_ptr<const SchedulableStatus>(new SchedulableStatus(*(p->get_item_at(i))));
return smart_ptr<SchedulableStatus>(new SchedulableStatus(*(p->get_item_at(i))));
return smart_ptr<const SchedulableStatus>(NULL);
return smart_ptr<SchedulableStatus>(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<const SchedulableList>
smart_ptr<SchedulableList>
History::get_simulation_status_at(int time) const
{
if (time > _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SchedulableList>(NULL);
return smart_ptr<SchedulableList>(NULL);
int trascorso = -1;
for(vector<Slice>::const_iterator i=_slices.begin(); i < _slices.end(); i++)
if (time <= trascorso + i->get_duration()) //FOUND!!
return smart_ptr<const SchedulableList>(new SchedulableList(*i->get_simulation_status()));
return smart_ptr<SchedulableList>(new SchedulableList(*i->get_simulation_status()));
else //Go on...
trascorso += i->get_duration();
//never reached if all slices are CONTIGUOUS (ans THIS shoul be!!)!!!
return smart_ptr<const SchedulableList>(NULL);
return smart_ptr<SchedulableList>(NULL);
}
int
@ -100,7 +100,7 @@ History::enqueue_slice(const SchedulableList& status)
if(_slices.size() == 0)
{
_slices.push_back(Slice(-1, 1, status));
_total_time_elapsed = 1;
_total_time_elapsed++;
notify();
return;
}

4
src/backend/history.hh
View File

@ -51,8 +51,8 @@ namespace sgpem
{
public:
memory::smart_ptr<const sgpem::SchedulableStatus> get_scheduled_at(int time) const;
memory::smart_ptr<const sgpem::SchedulableList> get_simulation_status_at(int time) const;
memory::smart_ptr<sgpem::SchedulableStatus> get_scheduled_at(int time) const;
memory::smart_ptr<sgpem::SchedulableList> get_simulation_status_at(int time) const;
int get_current_time() const;
void enqueue_slice(const sgpem::SchedulableList& status);
void truncate_at(int instant);

1
src/backend/observed_subject.cc
View File

@ -35,6 +35,7 @@ ObservedSubject::notify()
{
for(vector<Observer*>::iterator i = _attached.begin(); i < _attached.end(); i++)
(*i)->update();
}
/**

4
src/backend/policy.cc
View File

@ -34,8 +34,8 @@ Policy::get_id() const
}
const PolicyParameters&
Policy::get_parameters() const
PolicyParameters&
Policy::get_parameters()
{
return _parameters;
}

6
src/backend/policy.hh
View File

@ -22,6 +22,7 @@
#define POLICY_HH 1
#include "config.h"
#include "gettext.h"
#include "glibmm/ustring.h"
@ -50,10 +51,10 @@ namespace sgpem
virtual int get_time_slice() const = 0;
virtual void set_time_slice(const int&) = 0;
const PolicyParameters& get_parameters() const;
PolicyParameters& get_parameters();
private:
protected:
PolicyParameters _parameters;
int _id;
};
@ -61,5 +62,4 @@ namespace sgpem
}//~ namespace sgpem
#endif

2
src/backend/schedulable_list.cc
View File

@ -134,7 +134,7 @@ SchedulableList::remove(const uint& position)
}
/**
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)

71
src/backend/scheduler.cc
View File

@ -75,29 +75,46 @@ Scheduler::get_policy()
void
Scheduler::step_forward()
{
History& h = History::get_instance();
//******************
//check for arrivals and prepare the queue
//******************
smart_ptr<const SchedulableList> initial = h.get_simulation_status_at(h.get_current_time());
smart_ptr<SchedulableList> initial = h.get_simulation_status_at(h.get_current_time());
if (!initial)
{
cout << _("\nNo initial state inserted!!\n");
return;
}
_ready_queue.clear();
//adds running schedulable
smart_ptr<const SchedulableStatus> running_ptr = h.get_scheduled_at(h.get_current_time());
smart_ptr<SchedulableStatus> running_ptr = h.get_scheduled_at(h.get_current_time());
if (running_ptr)
_ready_queue.add_at_top(*running_ptr);
//adds the READY ones
for(uint rea=0; rea < initial->size(); rea++)
if (initial->get_item_at(rea)->get_state() == SchedulableStatus::state_ready)
_ready_queue.add_at_bottom(*initial->get_item_at(rea));
//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
if (initial->get_item_at(i)->get_state() == SchedulableStatus::state_future
&& (int)initial->get_item_at(i)->get_schedulable()->get_arrival_time() == h.get_current_time())
{
_ready_queue.add_at_bottom(*initial->get_item_at(i));
//cout << "\nnuovo running: " << initial->get_item_at(i)->get_schedulable()->get_name();
//pops the running schedulable only if the policy is not preemptive
//restore the old running schedulable
if (_policy->is_pre_emptive() == false && running_ptr)
_ready_queue.remove(0);
//adds the NEW one
_ready_queue.add_at_bottom(*initial->get_item_at(i));
_ready_queue.get_item_at(_ready_queue.size()-1)->set_state(SchedulableStatus::state_ready);
initial->get_item_at(i)->set_state(SchedulableStatus::state_ready);
// Sort the queue
_policy->sort_queue(event_schedulable_arrival);
@ -106,19 +123,24 @@ Scheduler::step_forward()
_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!
//there is a running schedulable and it's terminated. Append at the bottom with the state TERMINATED
for(uint i=0; i < _ready_queue.size(); i++)
if (*_ready_queue.get_item_at(i) == *running_ptr)
{
_ready_queue.add_at_bottom(*_ready_queue.get_item_at(i));
_ready_queue.remove(i);
_ready_queue.get_item_at(_ready_queue.size()-1)->set_state(SchedulableStatus::state_terminated);
break;
}
//cout << "\nTERMINATO!!";
running_ptr = NULL;
//IF _ready_queue.size() == 0 sort_queue(...) is called but has no effect!!
_policy->sort_queue(event_schedulable_termination);
@ -134,30 +156,31 @@ Scheduler::step_forward()
// 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);
if (_ready_queue.size() != 0 && (_ready_queue.get_item_at(0)->get_state() == SchedulableStatus::state_ready
|| _ready_queue.get_item_at(0)->get_state() == SchedulableStatus::state_running))
{
//the first ready element IS the running one (if != *running_ptr then there is a CONTEXT SWICH)
_ready_queue.get_item_at(0)->set_state(SchedulableStatus::state_running);
_ready_queue.get_item_at(0)->give_cpu_time(1);
}
//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);
for (uint i = 1; i < _ready_queue.size(); i++)
if (_ready_queue.get_item_at(i)->get_state() == SchedulableStatus::state_running)
_ready_queue.get_item_at(i)->set_state(SchedulableStatus::state_ready);
//append blocked, future, terminated and the old running schedulables
//append blocked, future, and terminated 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
&& (int)initial->get_item_at(i)->get_schedulable()->get_arrival_time() != h.get_current_time()) )
final.add_at_bottom(*initial->get_item_at(i));
|| initial->get_item_at(i)->get_state() == SchedulableStatus::state_terminated)
_ready_queue.add_at_bottom(*initial->get_item_at(i));
h.enqueue_slice(final);
cout << "\n";
/* for (uint i = 0; i < _ready_queue.size(); i++)
cout << " " << _ready_queue.get_item_at(i)->get_schedulable()->get_name()
<<"_" << _ready_queue.get_item_at(i)->get_state();
*/
h.enqueue_slice(_ready_queue);
}

2
src/backend/scheduler.hh
View File

@ -28,7 +28,7 @@ namespace sgpem
#include "config.h"
#include <limits>
#include <iostream>
#include "observed_subject.hh"
#include "history.hh"

1
src/graphical_simulation.hh
View File

@ -60,4 +60,3 @@ namespace sgpem {
}
#endif

5
src/io_manager.hh
View File

@ -28,7 +28,6 @@
namespace sgpem {
class IOManager;
/**
@ -42,7 +41,7 @@ namespace sgpem {
/**Writes a string into an output (the console, a text widget, ...)
\returns the number of charaters written
*/
virtual unsigned int write_buffer(const Glib::ustring& buffer) = 0;
virtual uint write_buffer(const Glib::ustring& buffer) = 0;
/**Reads a command from an interactive input (the console, a text widget, ...)
\returns a trimmed string (without blank spaces, tabs... at the extremities)
@ -57,5 +56,3 @@ namespace sgpem {
}
#endif

54
src/main.cc
View File

@ -34,9 +34,13 @@
#include "backend/process.hh"
#include "backend/policy.hh"
#include "backend/policy_parameters.hh"
#include "backend/python_policy.hh"
#include "backend/python_policy_manager.hh"
#include "standard_io.hh"
#include "text_simulation.hh"
#include "backend/dummy_policy.hh"
#include <glibmm/ustring.h>
#include <iostream>
@ -73,31 +77,54 @@ main(int argc, char* argv[])
}
*/
// Set the unique POLICY
DummyPolicy pol;
pol.configure();
pol.get_parameters().set_int("var2", 33);
pol.get_parameters().set_float("multiplier", 100);
pol.get_parameters().set_string("che_ne_so", "ciao");
Scheduler::get_instance().set_policy(&pol);
TextSimulation text_sim;
History::get_instance().attach(&text_sim);
//textual IO
smart_ptr<IOManager> io(new StandardIO());
text_sim.add_io_device(io);
// Create an INITIAL STATE
Process p1("P1", 0,5,1);
Process p2("P2", 0,5,2);
Process p3("P3", 5,3,3);
Process p4("P4", 6,2,3);
Process p5("P5", 1,2,3);
Process p6("P6", 10,2,1);
SchedulableStatus ss1(p1);
SchedulableStatus ss2(p2);
SchedulableStatus ss3(p3);
SchedulableStatus ss4(p4);
SchedulableStatus ss5(p5);
SchedulableStatus ss6(p6);
SchedulableList initial;
initial.add_at_bottom(ss1);
initial.add_at_bottom(ss2);
initial.add_at_bottom(ss3);
initial.add_at_bottom(ss4);
initial.add_at_bottom(ss5);
initial.add_at_bottom(ss6);
History::get_instance().enqueue_slice(initial);
//grafical IO
start_gui(argc, argv);
//SMOKE-TEST for backend classes
/* cout << "\n\n********************************";
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); 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);
//************** TEST HISTORY
@ -170,4 +197,3 @@ main(int argc, char* argv[])
*/
return 0;
}

14
src/simulation.cc
View File

@ -25,7 +25,7 @@ using namespace sgpem;
using namespace memory;
using Glib::usleep;
Simulation::Simulation(): _state(state_paused), _mode(false), _timer_interval(1000)
Simulation::Simulation(): _state(state_paused), _mode(true), _timer_interval(1000)
{
}
@ -83,16 +83,17 @@ Simulation::run()
_state = state_running;
//******* CONTINUOUS TIME
if (_mode)
{
loop:
loop:
// chech for termination
bool all_term = true;
smart_ptr<const SchedulableList> left = h.get_simulation_status_at(h.get_current_time());
smart_ptr<SchedulableList> left = h.get_simulation_status_at(h.get_current_time());
for(uint i = 0; i < left->size(); i++)
if (left->get_item_at(i)->get_state() != SchedulableStatus::state_terminated)
{
all_term = true;
all_term = false;
break;
}
@ -122,11 +123,11 @@ Simulation::run()
{
// chech for termination
bool all_term = true;
smart_ptr<const SchedulableList> left = h.get_simulation_status_at(h.get_current_time());
smart_ptr<SchedulableList> left = h.get_simulation_status_at(h.get_current_time());
for(uint i = 0; i < left->size(); i++)
if (left->get_item_at(i)->get_state() != SchedulableStatus::state_terminated)
{
all_term = true;
all_term = false;
break;
}
@ -178,4 +179,3 @@ Simulation::get_avaiable_policies()
v.push_back(Scheduler::get_instance().get_policy());
return v;
}

1
src/simulation.hh
View File

@ -76,4 +76,3 @@ namespace sgpem
#endif

1
src/standard_io.cc
View File

@ -61,4 +61,3 @@ StandardIO::is_full_duplex()
{
return false;
}

1
src/standard_io.hh
View File

@ -49,4 +49,3 @@ namespace sgpem {
}
#endif

105
src/text_simulation.cc
View File

@ -95,7 +95,7 @@ check:
" depending the mode configured with SetMode (default=continuous)"));
return;
}
obj->_devices[quale]->write_buffer("\n\tRUN!!");
obj->run();
}
else if (arguments[param] == "PAUSE")
{
@ -105,7 +105,7 @@ check:
"\n-- PAUSE COMMAND --\nPauses the simulation. The next call to RUN will restart it."));
return;
}
obj->_devices[quale]->write_buffer("\n\tPAUSE!!");
obj->pause();
}
else if (arguments[param] == "STOP")
{
@ -116,7 +116,7 @@ check:
"bring the simulation to the FIRST instant and start it."));
return;
}
obj->_devices[quale]->write_buffer("\n\tSTOP!!");
obj->stop();
}
else if (arguments[param] == "RESET")
{
@ -126,8 +126,7 @@ check:
"\n-- RESET COMMAND --\nResets the simulation jumping back to the first instant."));
return;
}
obj->_devices[quale]->write_buffer("\n\tRESET!!");
obj->reset();
}
else if (arguments[param] == "QUIT")
{
@ -145,7 +144,8 @@ check:
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- YOU ARE JOKING ME --\nYou're really too dummy!!!\n"));
"\n-- Do you really want me to explain what HELP means? --"
"\n ************** YOU ARE JOKING ME !!! ************\n\n"));
exit(1);
}
if (arguments.size() == 1)
@ -293,13 +293,31 @@ check:
int_to_string(i_i->second.get_value(), temp);
obj->_devices[quale]->write_buffer("\tvalue=" + temp);
int_to_string(i_i->second.get_lower_bound(), temp);
obj->_devices[quale]->write_buffer(" lower=" + temp);
obj->_devices[quale]->write_buffer("\t\tlower=" + temp);
int_to_string(i_i->second.get_upper_bound(), temp);
obj->_devices[quale]->write_buffer(" upper=" + temp);
obj->_devices[quale]->write_buffer("\t\tupper=" + temp);
if (i_i->second.is_required())
obj->_devices[quale]->write_buffer(" required=true");
obj->_devices[quale]->write_buffer("\t\trequired=true");
else
obj->_devices[quale]->write_buffer(" required=false");
obj->_devices[quale]->write_buffer("\t\trequired=false");
}
map<ustring, PolicyParameters::Parameter<float> > map_f = param.get_registered_float_parameters();
map<ustring, PolicyParameters::Parameter<float> >::iterator i_f = map_f.begin();
for(; i_f != map_f.end(); i_f++)
{
obj->_devices[quale]->write_buffer("\nfloat\t" + i_f->second.get_name());
float_to_string(i_f->second.get_value(), temp);
obj->_devices[quale]->write_buffer("\tvalue=" + temp);
float_to_string(i_f->second.get_lower_bound(), temp);
obj->_devices[quale]->write_buffer("\t\tlower=" + temp);
float_to_string(i_f->second.get_upper_bound(), temp);
obj->_devices[quale]->write_buffer("\t\tupper=" + temp);
if (i_f->second.is_required())
obj->_devices[quale]->write_buffer("\t\trequired=true");
else
obj->_devices[quale]->write_buffer("\t\trequired=false");
}
map<ustring, PolicyParameters::Parameter<ustring> > map_s = param.get_registered_string_parameters();
@ -314,11 +332,13 @@ check:
else
obj->_devices[quale]->write_buffer(" required=false");
}
}
else
{
obj->_devices[quale]->write_buffer("\nCommand not recognized: ");
obj->_devices[quale]->write_buffer(_("\nCommand not recognized: "));
obj->_devices[quale]->write_buffer(arguments[param]);
obj->_devices[quale]->write_buffer(_("\nTyper HELP for a list of avaiable commands."));
return;
}
}
@ -327,6 +347,68 @@ check:
void
TextSimulation::update()
{
History& h = History::get_instance();
int when, pri;
ustring temp;
when = h.get_current_time();
smart_ptr<SchedulableList> ll = h.get_simulation_status_at(when);
int_to_string(when, temp);
if (when<10)
_devices[0]->write_buffer("\n ");
else
_devices[0]->write_buffer("\n");
_devices[0]->write_buffer(temp + ") [RUNS]");
//insert the RUNNING ONE
smart_ptr<SchedulableStatus> running = h.get_scheduled_at(when);
if (running)
{
pri = running->get_schedulable()->get_priority();
int_to_string(pri, temp);
_devices[0]->write_buffer(" " + running->get_schedulable()->get_name() + "_(" + temp + ")");
}
_devices[0]->write_buffer(" --[READY]");
//insert the READY ones
for (uint i = 0; i < ll->size(); i++)
if (ll->get_item_at(i)->get_state() == SchedulableStatus::state_ready)
{
pri = ll->get_item_at(i)->get_schedulable()->get_priority();
int_to_string(pri, temp);
_devices[0]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
}
_devices[0]->write_buffer(" --[BLOCKED]");
//insert the BLOCKED ones
for (uint i = 0; i < ll->size(); i++)
if (ll->get_item_at(i)->get_state() == SchedulableStatus::state_blocked)
{
pri = ll->get_item_at(i)->get_schedulable()->get_priority();
int_to_string(pri, temp);
_devices[0]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
}
_devices[0]->write_buffer(" --[FUTURE]");
//insert the FUTURE ones
for (uint i = 0; i < ll->size(); i++)
if (ll->get_item_at(i)->get_state() == SchedulableStatus::state_future)
{
pri = ll->get_item_at(i)->get_schedulable()->get_priority();
int_to_string(pri, temp);
_devices[0]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
}
_devices[0]->write_buffer(" --[TERM]");
//insert the TERMINATED ones
for (uint i = 0; i < ll->size(); i++)
if (ll->get_item_at(i)->get_state() == SchedulableStatus::state_terminated)
{
pri = ll->get_item_at(i)->get_schedulable()->get_priority();
int_to_string(pri, temp);
_devices[0]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
}
}
@ -351,4 +433,3 @@ TextSimulation::_io_loop(pair<TextSimulation* , int > pun)
pun.first->parse_command(p);
}
}