- First implementation of a SimulationController in the GUI
that uses a callback to run the simulation in continuous mode. It isn't finished yet. git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@948 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
tchernobog
parent
1cdd2a6a9e
commit
3689424217
|
|
@ -37,11 +37,9 @@ using namespace sgpem;
|
|||
using namespace memory;
|
||||
|
||||
ConcreteSimulation::ConcreteSimulation() :
|
||||
_state(state_stopped), _mode(mode_continuous), _policy(NULL)
|
||||
{
|
||||
_notify = false;
|
||||
_front = 0;
|
||||
}
|
||||
Simulation(), _state(state_stopped),
|
||||
_mode(mode_continuous), _policy(NULL)
|
||||
{}
|
||||
|
||||
void
|
||||
ConcreteSimulation::set_mode(const mode new_mode)
|
||||
|
|
@ -61,16 +59,20 @@ ConcreteSimulation::jump_to(History::position p)
|
|||
switch (_state)
|
||||
{
|
||||
case state_running:
|
||||
pause();
|
||||
// pauses the simulation (see below)
|
||||
break;
|
||||
case state_stopped:
|
||||
_history.reset(true);
|
||||
_front = 0;
|
||||
break;
|
||||
default:
|
||||
;
|
||||
break;
|
||||
}
|
||||
|
||||
// Disable momentarily updates for registered observers on
|
||||
// sgpem::Simulation too.
|
||||
// See History for an example of how to implement this.
|
||||
set_notify_enabled(false);
|
||||
pause();
|
||||
|
||||
// Disable updates to registered observers
|
||||
|
|
@ -87,6 +89,10 @@ ConcreteSimulation::jump_to(History::position p)
|
|||
// Reenables updates to registered observers.
|
||||
// Calls _history.notify_change() on reactivation.
|
||||
_history.set_notify_enabled(true);
|
||||
|
||||
// Do the same for notifications on the state
|
||||
// of Simulation
|
||||
set_notify_enabled(true);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -94,16 +100,20 @@ void
|
|||
ConcreteSimulation::pause()
|
||||
{
|
||||
if(_state != state_paused)
|
||||
notify_change();
|
||||
{
|
||||
_state = state_paused;
|
||||
notify_change();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ConcreteSimulation::stop()
|
||||
{
|
||||
if(_state != state_stopped)
|
||||
notify_change();
|
||||
{
|
||||
_state = state_stopped;
|
||||
notify_change();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -111,14 +121,12 @@ ConcreteSimulation::run() throw(UserInterruptException, NullPolicyException, Mal
|
|||
{
|
||||
switch (_state)
|
||||
{
|
||||
case state_running:
|
||||
return;
|
||||
case state_stopped:
|
||||
_history.reset(true);
|
||||
_front = 0;
|
||||
break;
|
||||
default:
|
||||
;
|
||||
break;
|
||||
}
|
||||
|
||||
_state = state_running;
|
||||
|
|
@ -126,8 +134,20 @@ ConcreteSimulation::run() throw(UserInterruptException, NullPolicyException, Mal
|
|||
//step forward
|
||||
bool yet_to_finish = step();
|
||||
if (yet_to_finish)
|
||||
{
|
||||
if(_mode == mode_step_by_step)
|
||||
pause();
|
||||
else
|
||||
// We remain in running state, and we notify everybody!
|
||||
// This is non-trivial, and we must do so since we
|
||||
// put the state to running inconditionally. Don't
|
||||
// touch this if you don't provide another way to tell
|
||||
// a SimulationObserver that the simulation advanced
|
||||
// and *yet* it is in running state!
|
||||
notify_change();
|
||||
}
|
||||
else
|
||||
// Simulation ended
|
||||
stop();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -35,6 +35,11 @@ using namespace sgpem;
|
|||
// Explicit template instantiation to allow to export symbols from the DSO.
|
||||
template class SG_DLLEXPORT Singleton<ConcreteSimulation>;
|
||||
|
||||
Simulation::Simulation()
|
||||
: _notify(true), _front(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
Simulation::~Simulation()
|
||||
{}
|
||||
|
|
@ -68,7 +73,7 @@ unsigned int Simulation::get_front() const
|
|||
void
|
||||
Simulation::notify_change()
|
||||
{
|
||||
//if (!_notify) return; // what's the purpose of this?
|
||||
if (!_notify) return;
|
||||
|
||||
for (RegisteredObservers::iterator it = _observers.begin();
|
||||
it != _observers.end(); it++)
|
||||
|
|
|
|||
|
|
@ -67,9 +67,9 @@ namespace sgpem
|
|||
public:
|
||||
enum state
|
||||
{
|
||||
state_running,
|
||||
state_paused,
|
||||
state_stopped
|
||||
state_running = 0xdeafd0d0,
|
||||
state_paused = 0xbaddcafe,
|
||||
state_stopped = 0xdeadbeef
|
||||
};
|
||||
|
||||
enum mode
|
||||
|
|
@ -78,7 +78,7 @@ namespace sgpem
|
|||
mode_continuous = 1
|
||||
};
|
||||
|
||||
virtual ~Simulation();
|
||||
virtual ~Simulation() = 0;
|
||||
|
||||
/**
|
||||
\brief Runs the simulation.
|
||||
|
|
@ -176,13 +176,14 @@ namespace sgpem
|
|||
RegisteredObservers _observers;
|
||||
|
||||
// since no constructor is available, these fields must be defined in concrete subclasses.
|
||||
bool _notify;
|
||||
History::position _front;
|
||||
|
||||
Simulation(); // Constructor
|
||||
|
||||
virtual void notify_change();
|
||||
|
||||
private:
|
||||
|
||||
bool _notify;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@
|
|||
#include "backend/serializer.hh"
|
||||
|
||||
#include <gdkmm/pixbuf.h>
|
||||
#include <glibmm/timer.h>
|
||||
#include <glibmm/ustring.h>
|
||||
#include <gtkmm/aboutdialog.h>
|
||||
#include <gtkmm/messagedialog.h>
|
||||
|
|
@ -46,8 +47,8 @@
|
|||
#include <gtkmm/menuitem.h>
|
||||
#include <gtkmm/scrolledwindow.h>
|
||||
#include <gtkmm/stock.h>
|
||||
#include <gtkmm/toolbutton.h>
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
using namespace sgpem;
|
||||
|
|
@ -189,7 +190,7 @@ GuiBuilder::on_file_saveas_activate()
|
|||
}
|
||||
|
||||
GuiBuilder::GuiBuilder(const std::string& gladefile)
|
||||
: _refXml(Xml::create(gladefile))
|
||||
: _refXml(Xml::create(gladefile)), _controller(Simulation::get_instance(), _refXml)
|
||||
{
|
||||
using namespace Gtk;
|
||||
|
||||
|
|
@ -211,37 +212,6 @@ GuiBuilder::GuiBuilder(const std::string& gladefile)
|
|||
file_saveas->signal_activate().connect(sigc::mem_fun(*this, &GuiBuilder::on_file_saveas_activate));
|
||||
|
||||
|
||||
// Start, pause and stop simulation from the toolbar
|
||||
// TODO: can we use action groups instead of this?
|
||||
Simulation& sim = Simulation::get_instance();
|
||||
|
||||
// FIXME: just to try; a proper way to select a policy has to be installed
|
||||
CPUPoliciesGatekeeper& pgk = CPUPoliciesGatekeeper::get_instance();
|
||||
CPUPolicy* policy = pgk.get_registered()[0]->get_avail_policies()[1]; // RoundRobin at the moment of writing
|
||||
std::cout << "Selected policy : " << policy->get_name() << std::endl;
|
||||
pgk.activate_policy(&sim.get_history(), policy);
|
||||
sim.set_policy(policy);
|
||||
|
||||
ToolButton *toolbt_start, *toolbt_pause, *toolbt_stop;
|
||||
_refXml->get_widget("ToolBar.Play", toolbt_start);
|
||||
_refXml->get_widget("ToolBar.Pause", toolbt_pause);
|
||||
_refXml->get_widget("ToolBar.Stop", toolbt_stop);
|
||||
toolbt_start->signal_clicked().connect(sigc::mem_fun(sim, &Simulation::run));
|
||||
toolbt_pause->signal_clicked().connect(sigc::mem_fun(sim, &Simulation::pause));
|
||||
toolbt_stop->signal_clicked().connect(sigc::mem_fun(sim, &Simulation::stop));
|
||||
// Sensitivities
|
||||
toolbt_start->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_stop, &ToolButton::set_sensitive), true));
|
||||
toolbt_start->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_pause, &ToolButton::set_sensitive), true));
|
||||
toolbt_start->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_start, &ToolButton::set_sensitive), false));
|
||||
|
||||
toolbt_pause->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_start, &ToolButton::set_sensitive), true));
|
||||
toolbt_pause->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_pause, &ToolButton::set_sensitive), false));
|
||||
|
||||
toolbt_stop->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_stop, &ToolButton::set_sensitive), false));
|
||||
toolbt_stop->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_pause, &ToolButton::set_sensitive), false));
|
||||
toolbt_stop->signal_clicked().connect(sigc::bind(sigc::mem_fun(*toolbt_start, &ToolButton::set_sensitive), true));
|
||||
|
||||
|
||||
// Connect extra signals (decide where to do this...
|
||||
// here -- ugly -- derive widgets and then use
|
||||
// Glade::Xml::get_widget_derived -- better --)
|
||||
|
|
@ -287,6 +257,13 @@ GuiBuilder::GuiBuilder(const std::string& gladefile)
|
|||
simulation_window->add(*simulation_widget);
|
||||
simulation_widget->show();
|
||||
|
||||
|
||||
// ** FIXME: just to try; a proper way to select a policy has to be installed
|
||||
Simulation& sim = Simulation::get_instance();
|
||||
CPUPoliciesGatekeeper& pgk = CPUPoliciesGatekeeper::get_instance();
|
||||
CPUPolicy* policy = pgk.get_registered()[0]->get_avail_policies()[1]; // RoundRobin at the moment of writing
|
||||
std::cout << "Selected policy : " << policy->get_name() << std::endl;
|
||||
sim.set_policy(policy);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -311,3 +288,118 @@ GuiBuilder::open_file(const std::string& filename)
|
|||
std::cout << _("Filename to open: ") << filename << std::endl;
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
SimulationController::SimulationController(Simulation& simulation, Glib::RefPtr<Xml> main_window)
|
||||
: _sim(simulation), _refXml(main_window), _break_requested(false)
|
||||
{
|
||||
using namespace Gtk;
|
||||
|
||||
_sim.attach(*this);
|
||||
|
||||
// Start, pause and stop simulation from the toolbar
|
||||
// TODO: can we use action groups instead of this?
|
||||
|
||||
_refXml->get_widget("ToolBar.Play", _toolbt_start);
|
||||
_refXml->get_widget("ToolBar.Pause", _toolbt_pause);
|
||||
_refXml->get_widget("ToolBar.Stop", _toolbt_stop);
|
||||
_toolbt_start->signal_clicked().connect(sigc::mem_fun(*this, &SimulationController::on_simulation_run));
|
||||
_toolbt_pause->signal_clicked().connect(sigc::mem_fun(*this, &SimulationController::on_simulation_pause));
|
||||
_toolbt_stop->signal_clicked().connect(sigc::mem_fun(*this, &SimulationController::on_simulation_stop));
|
||||
}
|
||||
|
||||
|
||||
SimulationController::~SimulationController()
|
||||
{
|
||||
_sim.detach(*this);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SimulationController::on_simulation_run()
|
||||
{
|
||||
// Sensitivities
|
||||
_toolbt_start->set_sensitive(false);
|
||||
_toolbt_pause->set_sensitive(true);
|
||||
_toolbt_stop->set_sensitive(true);
|
||||
|
||||
_break_requested = false;
|
||||
_sim.run();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SimulationController::on_simulation_pause()
|
||||
{
|
||||
// Sensitivities
|
||||
_toolbt_start->set_sensitive(true);
|
||||
_toolbt_pause->set_sensitive(false);
|
||||
_toolbt_stop->set_sensitive(true);
|
||||
|
||||
_break_requested = true;
|
||||
_sim.pause();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SimulationController::on_simulation_stop()
|
||||
{
|
||||
// Sensitivities
|
||||
_toolbt_start->set_sensitive(true);
|
||||
_toolbt_pause->set_sensitive(false);
|
||||
_toolbt_stop->set_sensitive(false);
|
||||
|
||||
_break_requested = true;
|
||||
_sim.stop();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SimulationController::update(const Simulation& simulation)
|
||||
{
|
||||
std::cerr << "SimulationController::update(), simulation state == " << std::hex << simulation.get_state() << std::endl;
|
||||
|
||||
if(_break_requested)
|
||||
return;
|
||||
|
||||
switch(simulation.get_state())
|
||||
{
|
||||
case Simulation::state_stopped:
|
||||
on_simulation_stop();
|
||||
return;
|
||||
case Simulation::state_paused:
|
||||
on_simulation_pause();
|
||||
return;
|
||||
case Simulation::state_running:
|
||||
// Go on with the rest of the method...
|
||||
break;
|
||||
}
|
||||
|
||||
// We should never enter here, if the code is correct:
|
||||
// a step by step simulation should always be in paused
|
||||
// or stopped state after performing a single step
|
||||
assert(simulation.get_mode() != Simulation::mode_step_by_step);
|
||||
|
||||
switch(simulation.get_mode())
|
||||
{
|
||||
case Simulation::mode_continuous:
|
||||
{
|
||||
int timeout = GlobalPreferences::get_instance().get_speed();
|
||||
Glib::signal_timeout().connect(sigc::mem_fun(*this, &SimulationController::run_simulation_adaptor), timeout);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// Never gets here.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
SimulationController::run_simulation_adaptor()
|
||||
{
|
||||
if(!_break_requested)
|
||||
_sim.run();
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,6 +24,9 @@
|
|||
#include "config.h"
|
||||
#include "simulation_widget.hh"
|
||||
|
||||
#include "backend/simulation_observer.hh"
|
||||
|
||||
#include <gtkmm/toolbutton.h>
|
||||
#include <gtkmm/window.h>
|
||||
#include <libglademm/xml.h>
|
||||
|
||||
|
|
@ -35,6 +38,38 @@
|
|||
namespace sgpem
|
||||
{
|
||||
|
||||
class GuiBuilder;
|
||||
class SimulationController;
|
||||
|
||||
|
||||
// Helper class for controlling the simulation via callbacks
|
||||
// TODO: move me to another file.
|
||||
class SimulationController : public SimulationObserver
|
||||
{
|
||||
public:
|
||||
SimulationController(Simulation& simulation, Glib::RefPtr<Gnome::Glade::Xml> main_window);
|
||||
virtual ~SimulationController();
|
||||
|
||||
void update(const Simulation& simulation);
|
||||
|
||||
private:
|
||||
void on_simulation_run();
|
||||
void on_simulation_pause();
|
||||
void on_simulation_stop();
|
||||
|
||||
bool run_simulation_adaptor();
|
||||
|
||||
Simulation& _sim;
|
||||
Glib::RefPtr<Gnome::Glade::Xml> _refXml;
|
||||
bool _break_requested;
|
||||
|
||||
Gtk::ToolButton* _toolbt_start;
|
||||
Gtk::ToolButton* _toolbt_pause;
|
||||
Gtk::ToolButton* _toolbt_stop;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class GuiBuilder
|
||||
{
|
||||
public:
|
||||
|
|
@ -51,6 +86,7 @@ namespace sgpem
|
|||
private:
|
||||
Glib::RefPtr<Gnome::Glade::Xml> _refXml;
|
||||
SimulationWidget* _simulation_widget;
|
||||
SimulationController _controller;
|
||||
};
|
||||
|
||||
} //~ namespace sgpem
|
||||
|
|
|
|||
Loading…
Reference in New Issue