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

- Give code a round of indentation. Thank astyle, not me.

Browse source 
git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@837 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
tchernobog 2006-08-09 14:38:45 +00:00
parent aaf8e068d3
commit d3c7b46853
108 changed files with 3196 additions and 3180 deletions
Download patch file Download diff file Expand all files Collapse all files

136
src/backend/concrete_environment.cc
View file

@ -42,82 +42,82 @@ ConcreteEnvironment::ConcreteEnvironment()
ConcreteEnvironment::ConcreteEnvironment(const ConcreteEnvironment& ce) :
Environment(ce), _resources(ce._resources), _processes(), _sched_queue(), _sreq_queues(ce._sreq_queues)
Environment(ce), _resources(ce._resources), _processes(), _sched_queue(), _sreq_queues(ce._sreq_queues)
{
// The ReadyQueue won't be copied. Pointers to objects contained into
// the ready queue _will_ have changed in the new one. The ready queue
// needs to be reset: it is Scheduler that builds it again from time to time.
// The ReadyQueue won't be copied. Pointers to objects contained into
// the ready queue _will_ have changed in the new one. The ready queue
// needs to be reset: it is Scheduler that builds it again from time to time.
// Update resource pointers in a way you won't like :-)
{
for(Resources::iterator it = _resources.begin(); it != _resources.end(); it++)
it->second = new DynamicResource(dynamic_cast<const DynamicResource&>(*it->second));
}
// Update resource pointers in a way you won't like :-)
{
for (Resources::iterator it = _resources.begin(); it != _resources.end(); it++)
it->second = new DynamicResource(dynamic_cast<const DynamicResource&>(*it->second));
}
// DynamicProcess object need to be copied.
// The deep copy is guaranteed by the DynamicProcess copy constructor
{
const Processes& ce_proc = ce._processes;
insert_iterator<Processes> dest(_processes, _processes.begin());
for(Processes::const_iterator orig = ce_proc.begin(); orig != ce_proc.end(); orig++)
*dest++ = new DynamicProcess(dynamic_cast<const DynamicProcess&>(**orig));
}
{
const Processes& ce_proc = ce._processes;
insert_iterator<Processes> dest(_processes, _processes.begin());
for (Processes::const_iterator orig = ce_proc.begin(); orig != ce_proc.end(); orig++)
*dest++ = new DynamicProcess(dynamic_cast<const DynamicProcess&>(**orig));
}
// Update the subrequest queues.
// Update the subrequest queues.
// for each subrequest
typedef Processes::const_iterator it1_t;
// for each subrequest
typedef Processes::const_iterator it1_t;
typedef std::vector<Thread*> v2_t;
typedef v2_t::const_iterator it2_t;
typedef std::vector<Thread*> v2_t;
typedef v2_t::const_iterator it2_t;
typedef std::vector<Request*> v3_t;
typedef v3_t::const_iterator it3_t;
typedef std::vector<Request*> v3_t;
typedef v3_t::const_iterator it3_t;
typedef std::vector<SubRequest*> v4_t;
typedef v4_t::const_iterator it4_t;
typedef std::vector<SubRequest*> v4_t;
typedef v4_t::const_iterator it4_t;
typedef SubRequestQueue::iterator it5_t;
typedef SubRequestQueue::iterator it5_t;
for (it1_t it1 = _processes.begin(); it1 != _processes.end(); it1++)
{
const v2_t& threads = (*it1)->get_threads();
for (it2_t it2 = threads.begin(); it2 != threads.end(); it2++)
{
const v3_t& reqs = (*it2)->get_requests();
for (it3_t it3 = reqs.begin(); it3 != reqs.end(); it3++)
{
// an optimization here: there is no reason in iterating through
// future or exausted requests. (Do you know why?)
const v4_t& subr = (*it3)->get_subrequests();
for (it4_t it4 = subr.begin(); it4 != subr.end(); it4++)
{
SubRequest::state curr_state = (*it4)->get_state();
if (curr_state != Request::state_future && curr_state != Request::state_exhausted)
{
// the subrequest is the following queue:
SubRequestQueue & queue = get_request_queue((*it4)->get_resource_key());
// we must replace the old pointer:
bool found = false;
for (it5_t it5 = queue.begin(); !found && it5 != queue.end(); it5++)
{
DynamicSubRequest& _old = dynamic_cast<DynamicSubRequest&>(**it5);
DynamicSubRequest& _new = dynamic_cast<DynamicSubRequest&>(**it4);
if (&_old.get_core() == &_new.get_core())
{
found = true;
*it5 = *it4;
}
}
}
}
}
}
}
for(it1_t it1 = _processes.begin(); it1 != _processes.end(); it1++)
{
const v2_t& threads = (*it1)->get_threads();
for(it2_t it2 = threads.begin(); it2 != threads.end(); it2++)
{
const v3_t& reqs = (*it2)->get_requests();
for(it3_t it3 = reqs.begin(); it3 != reqs.end(); it3++)
{
// an optimization here: there is no reason in iterating through
// future or exausted requests. (Do you know why?)
const v4_t& subr = (*it3)->get_subrequests();
for(it4_t it4 = subr.begin(); it4 != subr.end(); it4++)
{
SubRequest::state curr_state = (*it4)->get_state();
if(curr_state != Request::state_future && curr_state != Request::state_exhausted)
{
// the subrequest is the following queue:
SubRequestQueue & queue = get_request_queue((*it4)->get_resource_key());
// we must replace the old pointer:
bool found = false;
for(it5_t it5 = queue.begin(); !found && it5 != queue.end(); it5++)
{
DynamicSubRequest& _old = dynamic_cast<DynamicSubRequest&>(**it5);
DynamicSubRequest& _new = dynamic_cast<DynamicSubRequest&>(**it4);
if (&_old.get_core() == &_new.get_core())
{
found = true;
*it5 = *it4;
}
}
}
}
}
}
}
}
@ -195,14 +195,14 @@ ConcreteEnvironment::get_sorted_queue()
ConcreteEnvironment::~ConcreteEnvironment()
{
// This call will invoke the DynamicProcess virtual destructor
// Which will delete on cascade all DynamicThreads and so on.
for_each(_processes.begin(), _processes.end(),
memory::deletor<Process>());
// This call will invoke the DynamicProcess virtual destructor
// Which will delete on cascade all DynamicThreads and so on.
for_each(_processes.begin(), _processes.end(),
memory::deletor<Process>());
// We do the same with Resources.
for(Resources::iterator it = _resources.begin(); it != _resources.end(); it++)
delete it->second;
// We do the same with Resources.
for (Resources::iterator it = _resources.begin(); it != _resources.end(); it++)
delete it->second;
// After this, the destructor of _sched_queue is invoked (only invalid pointers)
// After that, the destructor of _processes is invoked (only invalid pointers)

33
src/backend/concrete_environment.hh
View file

@ -62,12 +62,12 @@ namespace sgpem
/// considered instant.
///
/// The Process objects returned are actually DynamicProcess
/// objects. A downcast to DynamicProcess is guaranteed to be
/// objects. A downcast to DynamicProcess is guaranteed to be
/// always safe.
///
/// \return a constant set of snapshots of processes
virtual const Processes&
get_processes() const;
get_processes() const;
@ -76,7 +76,7 @@ namespace sgpem
/// \return a set of snapshots of processes
/// \see get_processes()
virtual Processes&
get_processes();
get_processes();
@ -93,13 +93,13 @@ namespace sgpem
/// class which returns the Resource object indexed.
///
/// The Resource objects returned are actually DynamicResource
/// objects. A downcast to DynamicResource is guaranteed to be
/// objects. A downcast to DynamicResource is guaranteed to be
/// always safe.
///
/// \return a indexed constant set of snapshot of resources.
/// \see DynamicSybrequest::get_resource()
virtual const Resources&
get_resources() const;
get_resources() const;
@ -108,7 +108,7 @@ namespace sgpem
/// \return an indexed set of snapshots of resources
/// \see get_resources()
virtual Resources&
get_resources();
get_resources();
@ -118,16 +118,16 @@ namespace sgpem
/// are waiting for getting control of a limited-access resource.
///
/// The Request objects returned are actually DynamicRequest
/// objects. A downcast to DynamicRequest is guaranteed to be
/// objects. A downcast to DynamicRequest is guaranteed to be
/// always safe.
///
/// \param resource The resource the requests are for
/// \return The current ready requests queue.
virtual const SubRequestQueue&
get_request_queue(resource_key_t resource_key) const;
get_request_queue(resource_key_t resource_key) const;
SubRequestQueue&
get_request_queue(resource_key_t resource_key);
get_request_queue(resource_key_t resource_key);
@ -150,7 +150,7 @@ namespace sgpem
///
/// \return the current ready queue (constant).
virtual const ReadyQueue&
get_sorted_queue() const;
get_sorted_queue() const;
@ -159,14 +159,14 @@ namespace sgpem
/// \return the current ready queue.
/// \see get_sorted_queue()
virtual ReadyQueue&
get_sorted_queue();
get_sorted_queue();
/// \brief The standard virtual destructor.
/// The standard virtual destructor.
virtual
~ConcreteEnvironment();
~ConcreteEnvironment();
private:
@ -175,11 +175,11 @@ namespace sgpem
/// Actually contains only DynamicResource objects.
// resources come before processes because of
// destruction order. See destructor implementation
Resources _resources;
Resources _resources;
/// \brief The container of all Process objecs.
/// Actually contains only DynamicProcess objects.
Processes _processes;
Processes _processes;
/// \brief The queue of the ready schedulables
/// Does not contain the running process.
@ -187,7 +187,8 @@ namespace sgpem
SubRequestQueues _sreq_queues;
}; //~ class ConcreteEnvironment
}
; //~ class ConcreteEnvironment
} //~ namespace sgpem

474
src/backend/concrete_history.cc
View file

@ -54,372 +54,372 @@ using memory::deletor;
template<typename T>
static bool deep_remove(std::vector<T*>& v, const T& obj)
{
typedef typename std::vector<T*> Vector;
for(typename Vector::iterator it = v.begin(); it != v.end(); it++)
if(**it == obj)
{
delete *it;
v.erase(it);
return true;
}
return false;
typedef typename std::vector<T*> Vector;
for (typename Vector::iterator it = v.begin(); it != v.end(); it++)
if (**it == obj)
{
delete *it;
v.erase(it);
return true;
}
return false;
}
template<typename T>
static T* deep_find(const std::vector<T*>& v, const T& obj)
{
typedef typename std::vector<T*> Vector;
for(typename Vector::const_iterator it = v.begin(); it != v.end(); it++)
if(**it == obj)
{
return *it;
}
return NULL;
typedef typename std::vector<T*> Vector;
for (typename Vector::const_iterator it = v.begin(); it != v.end(); it++)
if (**it == obj)
{
return *it;
}
return NULL;
}
// -----------------
ConcreteHistory::ConcreteHistory()
: History(), _snapshots()
: History(), _snapshots()
{
_snapshots.push_back(new ConcreteEnvironment());
_snapshots.push_back(new ConcreteEnvironment());
}
ConcreteHistory::~ConcreteHistory()
{
for_each(_snapshots.begin(), _snapshots.end(),
deletor<ConcreteEnvironment>());
for_each(_snapshots.begin(), _snapshots.end(),
deletor<ConcreteEnvironment>());
}
ConcreteHistory::ConcreteHistory(const ConcreteHistory& h) :
History(h)
History(h)
{
typedef Snapshots::const_iterator SnapIt;
for(SnapIt it = h._snapshots.begin(); it != h._snapshots.end(); ++it)
for (SnapIt it = h._snapshots.begin(); it != h._snapshots.end(); ++it)
_snapshots.push_back(new ConcreteEnvironment(*(*it)));
}
void
ConcreteHistory::append_new_environment(ConcreteEnvironment* environment)
{
_snapshots.push_back(environment);
notify_change();
_snapshots.push_back(environment);
notify_change();
}
ConcreteHistory::size_t
ConcreteHistory::get_size() const
{
return _snapshots.size();
return _snapshots.size();
}
const ConcreteEnvironment&
const ConcreteEnvironment&
ConcreteHistory::get_last_environment() const
{
// Should always be true:
assert(_snapshots.size() > 0);
return *_snapshots.back();
// Should always be true:
assert(_snapshots.size() > 0);
return *_snapshots.back();
}
const ConcreteEnvironment&
ConcreteHistory::get_environment_at(position index) const
throw(std::out_of_range)
const ConcreteEnvironment&
ConcreteHistory::get_environment_at(position index) const
throw(std::out_of_range)
{
return *_snapshots.at(index);
return *_snapshots.at(index);
}
void
void
ConcreteHistory::remove(resource_key_t resource_key)
{
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Resources& resources = initial.get_resources();
ConcreteEnvironment::Resources::iterator found = resources.find(resource_key);
if(found == resources.end())
return;
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Resources& resources = initial.get_resources();
ConcreteEnvironment::Resources::iterator found = resources.find(resource_key);
if (found == resources.end())
return;
reset(false);
reset(false);
delete found->second;
resources.erase(found);
delete found->second;
resources.erase(found);
// Delete the queue associated with the resource.
ConcreteEnvironment::SubRequestQueues& srq = initial.get_subrequest_queues();
ConcreteEnvironment::SubRequestQueues::iterator qfound = srq.find(resource_key);
// There is always one!
assert(qfound != srq.end());
srq.erase(qfound);
// Delete the queue associated with the resource.
ConcreteEnvironment::SubRequestQueues& srq = initial.get_subrequest_queues();
ConcreteEnvironment::SubRequestQueues::iterator qfound = srq.find(resource_key);
// There is always one!
assert(qfound != srq.end());
srq.erase(qfound);
// Now search and erase subrequest that had a ref to the
// removed resource
// Now search and erase subrequest that had a ref to the
// removed resource
typedef std::vector<DynamicThread*> Threads;
typedef std::vector<DynamicRequest*> Requests;
typedef std::vector<DynamicSubRequest*> SubRequests;
typedef std::vector<DynamicThread*> Threads;
typedef std::vector<DynamicRequest*> Requests;
typedef std::vector<DynamicSubRequest*> SubRequests;
// Listening to "The Thing That Should Not Be"...
// all hail the cyclomatic complexity!
ConcreteEnvironment::Processes& processes = initial.get_processes();
typedef ConcreteEnvironment::Processes::iterator ProcIt;
for(ProcIt it1 = processes.begin(); it1 != processes.end(); it1++)
{
Threads& threads = dynamic_cast<DynamicProcess&>(**it1).get_dynamic_threads();
for(Threads::iterator it2 = threads.begin(); it2 != threads.end(); it2++)
{
Requests& reqs = (*it2)->get_dynamic_requests();
for(Requests::iterator it3 = reqs.begin(); it3 != reqs.end(); it3++)
{
SubRequests& subr = (*it3)->get_dynamic_subrequests();
SubRequests::iterator it4 = subr.begin();
while(it4 != subr.end())
if((*it4)->get_resource_key() == resource_key)
{
delete *it4;
it4 = subr.erase(it4);
}
else
it4++;
}
}
} //~ end monstrous construct, "The Thing That Should Not Be"
// Chtulhu ftaghn. There are worse things in life. Mother-in-laws,
// for example. Or hangovers. Or being read poetry by a Vogon.
// Although the above construct really rates between the first tens.
// Listening to "The Thing That Should Not Be"...
// all hail the cyclomatic complexity!
ConcreteEnvironment::Processes& processes = initial.get_processes();
typedef ConcreteEnvironment::Processes::iterator ProcIt;
for (ProcIt it1 = processes.begin(); it1 != processes.end(); it1++)
{
Threads& threads = dynamic_cast<DynamicProcess&>(**it1).get_dynamic_threads();
for (Threads::iterator it2 = threads.begin(); it2 != threads.end(); it2++)
{
Requests& reqs = (*it2)->get_dynamic_requests();
for (Requests::iterator it3 = reqs.begin(); it3 != reqs.end(); it3++)
{
SubRequests& subr = (*it3)->get_dynamic_subrequests();
SubRequests::iterator it4 = subr.begin();
while (it4 != subr.end())
if ((*it4)->get_resource_key() == resource_key)
{
delete *it4;
it4 = subr.erase(it4);
}
else
it4++;
}
}
} //~ end monstrous construct, "The Thing That Should Not Be"
// Chtulhu ftaghn. There are worse things in life. Mother-in-laws,
// for example. Or hangovers. Or being read poetry by a Vogon.
// Although the above construct really rates between the first tens.
notify_change();
notify_change();
}
void
ConcreteHistory::remove(Process& process)
{
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
bool found = deep_remove<Process>(processes, process);
if(found)
reset(true);
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
bool found = deep_remove<Process>(processes, process);
if (found)
reset(true);
}
void
void
ConcreteHistory::remove(Thread& thread)
{
DynamicThread& dyn_thr = dynamic_cast<DynamicThread&>(thread);
DynamicThread& dyn_thr = dynamic_cast<DynamicThread&>(thread);
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* found = deep_find<Process>(processes, dyn_thr.get_process());
if(found == NULL)
return; // not found, just return.
DynamicProcess& dynamic_found = dynamic_cast<DynamicProcess&>(*found);
bool removed = deep_remove<DynamicThread>(dynamic_found.get_dynamic_threads(), dyn_thr);
if (found == NULL)
return; // not found, just return.
if(removed)
reset(true);
DynamicProcess& dynamic_found = dynamic_cast<DynamicProcess&>(*found);
bool removed = deep_remove<DynamicThread>(dynamic_found.get_dynamic_threads(), dyn_thr);
if (removed)
reset(true);
}
void
ConcreteHistory::remove(Request& request)
{
DynamicRequest& dyn_req = dynamic_cast<DynamicRequest&>(request);
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
DynamicRequest& dyn_req = dynamic_cast<DynamicRequest&>(request);
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* proc_ref = deep_find<Process>(processes, dyn_proc);
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
if(dyn_proc_ref == NULL)
return; // not found, just return.
DynamicThread* thr_ref = deep_find<DynamicThread>(dyn_proc_ref->get_dynamic_threads(), dyn_thr);
if(thr_ref == NULL)
return; // not found, just return.
bool removed = deep_remove<DynamicRequest>(thr_ref->get_dynamic_requests(), dyn_req);
if(removed)
reset(true);
}
void
ConcreteHistory::remove(SubRequest& subrequest)
{
// this function makes one relevant assumption:
// the initial environment does contain empty request queues only.
DynamicSubRequest& dyn_sub = dynamic_cast<DynamicSubRequest&>(subrequest);
DynamicRequest& dyn_req = dyn_sub.get_request();
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* proc_ref = deep_find<Process>(processes, dyn_proc);
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
if(dyn_proc_ref == NULL)
return; // not found, just return.
DynamicThread* thr_ref = deep_find<DynamicThread>(dyn_proc_ref->get_dynamic_threads(), dyn_thr);
if(thr_ref == NULL)
return; // not found, just return.
DynamicRequest* req_ref = deep_find<DynamicRequest>(thr_ref->get_dynamic_requests(), dyn_req);
if(req_ref == NULL)
return; // not found, just return.
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
if (dyn_proc_ref == NULL)
return; // not found, just return.
DynamicThread* thr_ref = deep_find<DynamicThread>(dyn_proc_ref->get_dynamic_threads(), dyn_thr);
if (thr_ref == NULL)
return; // not found, just return.
bool removed = deep_remove<DynamicSubRequest>(req_ref->get_dynamic_subrequests(), dyn_sub);
bool removed = deep_remove<DynamicRequest>(thr_ref->get_dynamic_requests(), dyn_req);
if(removed)
reset(true);
if (removed)
reset(true);
}
ConcreteHistory::ResourcePair
void
ConcreteHistory::remove(SubRequest& subrequest)
{
// this function makes one relevant assumption:
// the initial environment does contain empty request queues only.
DynamicSubRequest& dyn_sub = dynamic_cast<DynamicSubRequest&>(subrequest);
DynamicRequest& dyn_req = dyn_sub.get_request();
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* proc_ref = deep_find<Process>(processes, dyn_proc);
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
if (dyn_proc_ref == NULL)
return; // not found, just return.
DynamicThread* thr_ref = deep_find<DynamicThread>(dyn_proc_ref->get_dynamic_threads(), dyn_thr);
if (thr_ref == NULL)
return; // not found, just return.
DynamicRequest* req_ref = deep_find<DynamicRequest>(thr_ref->get_dynamic_requests(), dyn_req);
if (req_ref == NULL)
return; // not found, just return.
bool removed = deep_remove<DynamicSubRequest>(req_ref->get_dynamic_subrequests(), dyn_sub);
if (removed)
reset(true);
}
ConcreteHistory::ResourcePair
ConcreteHistory::add_resource(const Glib::ustring& name,
bool preemptable,
size_t places,
size_t availability)
bool preemptable,
size_t places,
size_t availability)
{
reset(false);
reset(false);
typedef ConcreteEnvironment::Resources Resources;
typedef ConcreteEnvironment::SubRequestQueue SubRequestQueue;
// And preemptable and availability?? FIXME!
typedef ConcreteEnvironment::Resources Resources;
typedef ConcreteEnvironment::SubRequestQueue SubRequestQueue;
// And preemptable and availability?? FIXME!
StaticResource* core = new StaticResource(name, places);
DynamicResource* resource = new DynamicResource(core);
StaticResource* core = new StaticResource(name, places);
DynamicResource* resource = new DynamicResource(core);
ConcreteEnvironment::Resources& resources = _snapshots.front()->get_resources();
// alakazam! Black magic at work... get a unique index for this resource
resource_key_t index = 0;
while(resources.find(index) != resources.end())
index++;
// Found a hole in the map, fill it like little Hans,
// its finger and the spilling dam.
Resources::iterator temp = resources.insert(pair<resource_key_t,Resource*>(index, resource)).first;
// The same for request queues.
SubRequestQueue emptysrq;
_snapshots.front()->get_subrequest_queues().insert(pair<resource_key_t,SubRequestQueue>(index, emptysrq));
ConcreteEnvironment::Resources& resources = _snapshots.front()->get_resources();
notify_change();
// alakazam! Black magic at work... get a unique index for this resource
resource_key_t index = 0;
while (resources.find(index) != resources.end())
index++;
return *temp;
// Found a hole in the map, fill it like little Hans,
// its finger and the spilling dam.
Resources::iterator temp = resources.insert(pair<resource_key_t, Resource*>(index, resource)).first;
// The same for request queues.
SubRequestQueue emptysrq;
_snapshots.front()->get_subrequest_queues().insert(pair<resource_key_t, SubRequestQueue>(index, emptysrq));
notify_change();
return *temp;
}
DynamicProcess&
DynamicProcess&
ConcreteHistory::add_process(const Glib::ustring& name,
time_t arrival_time,
prio_t base_priority)
time_t arrival_time,
prio_t base_priority)
{
reset(false);
StaticProcess* core = new StaticProcess(name, arrival_time, base_priority);
DynamicProcess* proc = new DynamicProcess(core);
reset(false);
ConcreteEnvironment::Processes& processes = _snapshots.front()->get_processes();
processes.push_back(proc);
StaticProcess* core = new StaticProcess(name, arrival_time, base_priority);
DynamicProcess* proc = new DynamicProcess(core);
notify_change();
return *proc;
ConcreteEnvironment::Processes& processes = _snapshots.front()->get_processes();
processes.push_back(proc);
notify_change();
return *proc;
}
DynamicThread&
DynamicThread&
ConcreteHistory::add_thread(const Glib::ustring& name,
Process& parent,
time_t cpu_time,
time_t arrival_time,
prio_t base_priority)
Process& parent,
time_t cpu_time,
time_t arrival_time,
prio_t base_priority)
{
reset(false);
// Holy cow! *THIS* is ugly!!!!
DynamicProcess& parent_process = dynamic_cast<DynamicProcess&>(parent);
StaticProcess& parent_core = parent_process.get_core();
StaticThread* core = new StaticThread(name, parent_core, cpu_time, arrival_time, base_priority);
DynamicThread* thread = new DynamicThread(core, &parent_process);
notify_change();
return *thread;
reset(false);
// Holy cow! *THIS* is ugly!!!!
DynamicProcess& parent_process = dynamic_cast<DynamicProcess&>(parent);
StaticProcess& parent_core = parent_process.get_core();
StaticThread* core = new StaticThread(name, parent_core, cpu_time, arrival_time, base_priority);
DynamicThread* thread = new DynamicThread(core, &parent_process);
notify_change();
return *thread;
}
DynamicRequest&
DynamicRequest&
ConcreteHistory::add_request(Thread& owner,
time_t instant)
time_t instant)
{
reset(false);
DynamicThread& dyn_owner = dynamic_cast<DynamicThread&>(owner);
StaticThread& owner_core = dyn_owner.get_core();
StaticRequest* core = new StaticRequest(&owner_core, instant);
DynamicRequest* req = new DynamicRequest(core, &dyn_owner);
reset(false);
dyn_owner.get_requests().push_back(req);
DynamicThread& dyn_owner = dynamic_cast<DynamicThread&>(owner);
StaticThread& owner_core = dyn_owner.get_core();
notify_change();
return *req;
StaticRequest* core = new StaticRequest(&owner_core, instant);
DynamicRequest* req = new DynamicRequest(core, &dyn_owner);
dyn_owner.get_requests().push_back(req);
notify_change();
return *req;
}
DynamicSubRequest&
DynamicSubRequest&
ConcreteHistory::add_subrequest(Request& request,
resource_key_t resource_key,
time_t duration)
resource_key_t resource_key,
time_t duration)
{
reset(false);
DynamicRequest& dyn_request = dynamic_cast<DynamicRequest&>(request);
StaticSubRequest* core = new StaticSubRequest(resource_key, duration);
DynamicSubRequest* subreq = new DynamicSubRequest(core, &dyn_request);
reset(false);
dyn_request.get_subrequests().push_back(subreq);
DynamicRequest& dyn_request = dynamic_cast<DynamicRequest&>(request);
notify_change();
return *subreq;
StaticSubRequest* core = new StaticSubRequest(resource_key, duration);
DynamicSubRequest* subreq = new DynamicSubRequest(core, &dyn_request);
dyn_request.get_subrequests().push_back(subreq);
notify_change();
return *subreq;
}
void
ConcreteHistory::reset(bool notify)
{
assert(_snapshots.size() > 0);
Snapshots::iterator it = _snapshots.begin();
it++; // Skip first environment that we saved
for_each(it, _snapshots.end(), deletor<ConcreteEnvironment>());
_snapshots.resize(1); // Truncate to keep only our "model"
assert(_snapshots.size() > 0);
Snapshots::iterator it = _snapshots.begin();
it++; // Skip first environment that we saved
if(notify)
notify_change();
for_each(it, _snapshots.end(), deletor<ConcreteEnvironment>());
_snapshots.resize(1); // Truncate to keep only our "model"
if (notify)
notify_change();
}
void
ConcreteHistory::notify_change()
{
History::RegisteredObservers::iterator it;
for(it =_observers.begin(); it != _observers.end(); it++)
(*it)->update(*this);
History::RegisteredObservers::iterator it;
for (it = _observers.begin(); it != _observers.end(); it++)
(*it)->update(*this);
}

79
src/backend/concrete_history.hh
View file

@ -49,53 +49,54 @@ namespace sgpem
ConcreteHistory(const ConcreteHistory&);
virtual ~ConcreteHistory();
virtual void append_new_environment(ConcreteEnvironment* environment);
virtual size_t get_size() const;
virtual const ConcreteEnvironment& get_last_environment() const;
virtual const ConcreteEnvironment& get_environment_at(position index) const throw(std::out_of_range);
virtual void remove(resource_key_t resource_key);
virtual void remove(Process& process);
virtual void remove(Thread& thread);
virtual void remove(Request& request);
virtual void remove(SubRequest& subrequest);
virtual void append_new_environment(ConcreteEnvironment* environment);
virtual size_t get_size() const;
virtual const ConcreteEnvironment& get_last_environment() const;
virtual const ConcreteEnvironment& get_environment_at(position index) const throw(std::out_of_range);
virtual void remove(resource_key_t resource_key);
virtual void remove(Process& process);
virtual void remove(Thread& thread);
virtual void remove(Request& request);
virtual void remove(SubRequest& subrequest);
virtual ResourcePair add_resource(const Glib::ustring& name,
bool preemptable = false,
size_t places = 1,
size_t availability = 0);
virtual ResourcePair add_resource(const Glib::ustring& name,
bool preemptable = false,
size_t places = 1,
size_t availability = 0);
virtual DynamicProcess& add_process(const Glib::ustring& name,
time_t arrival_time,
prio_t base_priority = 0);
virtual DynamicProcess& add_process(const Glib::ustring& name,
time_t arrival_time,
prio_t base_priority = 0);
virtual DynamicThread& add_thread(const Glib::ustring& name,
Process& parent,
time_t cpu_time,
time_t arrival_time = 0,
prio_t base_priority = 0);
virtual DynamicThread& add_thread(const Glib::ustring& name,
Process& parent,
time_t cpu_time,
time_t arrival_time = 0,
prio_t base_priority = 0);
virtual DynamicRequest& add_request(Thread& owner,
time_t instant);
virtual DynamicRequest& add_request(Thread& owner,
time_t instant);
virtual DynamicSubRequest& add_subrequest(Request& request,
resource_key_t resource_key,
time_t duration);
virtual DynamicSubRequest& add_subrequest(Request& request,
resource_key_t resource_key,
time_t duration);
virtual void reset(bool notify = true);
protected:
typedef std::vector<ConcreteEnvironment*> Snapshots;
Snapshots _snapshots;
virtual void reset(bool notify = true);
virtual void notify_change();
private:
// Disable assignment, implement it only if needed
ConcreteHistory& operator=(const ConcreteHistory& op2);
}; //~ class ConcreteHistory
protected:
typedef std::vector<ConcreteEnvironment*> Snapshots;
Snapshots _snapshots;
virtual void notify_change();
private:
// Disable assignment, implement it only if needed
ConcreteHistory& operator=(const ConcreteHistory& op2);
}
; //~ class ConcreteHistory
}//~ namespace sgpem

88
src/backend/concrete_simulation.cc
View file

@ -32,8 +32,8 @@ using namespace sgpem;
using namespace memory;
using Glib::usleep;
ConcreteSimulation::ConcreteSimulation() :
_state(state_stopped), _mode(true), _timer_interval(1000), _policy(NULL)
ConcreteSimulation::ConcreteSimulation() :
_state(state_stopped), _mode(true), _timer_interval(1000), _policy(NULL)
{}
void
@ -75,7 +75,7 @@ ConcreteSimulation::stop()
void
ConcreteSimulation::run() throw(UserInterruptException, NullPolicyException)
{
switch(_state)
switch (_state)
{
case state_running:
return;
@ -88,57 +88,57 @@ ConcreteSimulation::run() throw(UserInterruptException, NullPolicyException)
_state = state_running;
if(get_policy() == NULL)
{
stop();
throw NullPolicyException("no policy selected");
}
if (get_policy() == NULL)
{
stop();
throw NullPolicyException("no policy selected");
}
//******* CONTINUOUS TIME
if (_mode)
{
do
{
try
{
try
{
//step forward
bool yet_to_finish = Scheduler::get_instance().step_forward(_history, *get_policy());
if(!yet_to_finish) stop();
//sleep
Glib::usleep(_timer_interval*1000);
}
catch(UserInterruptException e)
{
stop();
throw;
}
//check the state
if (_state == state_stopped || _state == state_paused)
return;
//step forward
bool yet_to_finish = Scheduler::get_instance().step_forward(_history, *get_policy());
if (!yet_to_finish) stop();
//sleep
Glib::usleep(_timer_interval*1000);
}
while(true);
catch (UserInterruptException e)
{
stop();
throw;
}
//check the state
if (_state == state_stopped || _state == state_paused)
return;
}
while (true);
}
//******* STEP by STEP
else
{
try
{
assert(get_policy() != NULL);
//step forward
bool yet_to_finish = Scheduler::get_instance().step_forward(_history, *get_policy());
if(yet_to_finish)
pause();
else
stop();
}
catch(UserInterruptException e)
{
{
assert(get_policy() != NULL);
//step forward
bool yet_to_finish = Scheduler::get_instance().step_forward(_history, *get_policy());
if (yet_to_finish)
pause();
else
stop();
throw;
}
}
catch (UserInterruptException e)
{
stop();
throw;
}
}
}
@ -158,8 +158,8 @@ void
ConcreteSimulation::set_policy(CPUPolicy* p)
{
_policy = p;
if(p != NULL)
if (p != NULL)
CPUPoliciesGatekeeper::get_instance().activate_policy(&_history, p);
}

2
src/backend/concrete_simulation.hh
View file

@ -42,7 +42,7 @@ namespace sgpem
void set_timer(const unsigned int);
int get_timer() const;
void set_mode(const bool&);
bool get_mode() const;

34
src/backend/cpu_policies_gatekeeper.cc
View file

@ -55,7 +55,7 @@ CPUPoliciesGatekeeper::register_manager(CPUPolicyManager* manager)
ManagerIterator end = _registered.end();
if(find(_registered.begin(), end, manager) == end)
if (find(_registered.begin(), end, manager) == end)
_registered.push_back(manager);
}
@ -67,7 +67,7 @@ CPUPoliciesGatekeeper::unregister_manager(CPUPolicyManager* manager)
ManagerIterator end = _registered.end();
ManagerIterator pos = find(_registered.begin(), end, manager);
if(pos != end)
if (pos != end)
{
deactivate_policies(*pos);
_registered.erase(pos);
@ -81,7 +81,7 @@ CPUPoliciesGatekeeper::get_current_policy(History* history) throw(runtime_error)
ActiveIterator policy = _active_policies.find(history);
if(policy == _active_policies.end())
if (policy == _active_policies.end())
throw runtime_error("No active policy associated with this "
"history is available.");
@ -96,10 +96,10 @@ CPUPoliciesGatekeeper::activate_policy(History *history, CPUPolicy* policy)
ActiveIterator end = _active_policies.end();
ActiveIterator pos = _active_policies.find(history);
if(pos != end && pos->second != policy)
if (pos != end && pos->second != policy)
_active_policies[history]->deactivate();
if(pos == end || pos->second != policy)
if (pos == end || pos->second != policy)
{
_active_policies[history] = policy;
_active_policies[history]->activate();
@ -119,23 +119,23 @@ CPUPoliciesGatekeeper::deactivate_policies(CPUPolicyManager* manager)
CPUPolicyIterator avail_it = avail_policies.begin();
CPUPolicyIterator avail_end = avail_policies.end();
for(; avail_it != avail_end; ++avail_it)
for (; avail_it != avail_end; ++avail_it)
{
// TODO isn't there a way to write more compact code by using
// library utilities?
ActiveIterator act_it = _active_policies.begin();
while(act_it != _active_policies.end())
{
if(act_it->second == *avail_it)
{
ActiveIterator removable = act_it++;
removable->second->deactivate();
_active_policies.erase(removable);
}
else
act_it++;
}
while (act_it != _active_policies.end())
{
if (act_it->second == *avail_it)
{
ActiveIterator removable = act_it++;
removable->second->deactivate();
_active_policies.erase(removable);
}
else
act_it++;
}
} //~ for(avail_it)
}

2
src/backend/cpu_policy_manager.cc
View file

@ -38,7 +38,7 @@ CPUPolicyManager::~CPUPolicyManager()
{
// This check is necessary:
//FIXME remove this when get_registered_manager is dropped
if(_registered == this) _registered = NULL;
if (_registered == this) _registered = NULL;
CPUPoliciesGatekeeper::get_instance().unregister_manager(this);
}

174
src/backend/dynamic_process.cc
View file

@ -32,28 +32,28 @@
using namespace sgpem;
using namespace std;
DynamicProcess::DynamicProcess(StaticProcess* core) :
DynamicSchedulable(), _core(core)
DynamicProcess::DynamicProcess(StaticProcess* core) :
DynamicSchedulable(), _core(core)
{
assert(core != NULL);
}
DynamicProcess::DynamicProcess(const DynamicProcess &other) :
Schedulable(), DynamicSchedulable(other), Process(),
_core(other._core)
Schedulable(), DynamicSchedulable(other), Process(),
_core(other._core)
{
typedef vector<DynamicThread*>::const_iterator ThreadIt;
const vector<DynamicThread*>& other_threads = other._dynamic_threads;
for(ThreadIt it = other_threads.begin(); it != other_threads.end(); ++it)
for (ThreadIt it = other_threads.begin(); it != other_threads.end(); ++it)
new DynamicThread(*(*it), this);
}
DynamicProcess::~DynamicProcess()
{
for_each(_dynamic_threads.begin(), _dynamic_threads.end(),
memory::deletor<DynamicThread>());
for_each(_dynamic_threads.begin(), _dynamic_threads.end(),
memory::deletor<DynamicThread>());
}
std::vector<Thread*>
@ -65,71 +65,71 @@ DynamicProcess::get_threads()
std::vector<const Thread*>
DynamicProcess::get_threads() const
{
return vector<const Thread*>(_dynamic_threads.begin(), _dynamic_threads.end());
return vector<const Thread*>(_dynamic_threads.begin(), _dynamic_threads.end());
}
Schedulable::state
DynamicProcess::get_state() const
{
int total = _dynamic_threads.size();
int running = 0;
int ready = 0;
int blocked = 0;
int terminated = 0;
int future = 0;
int total = _dynamic_threads.size();
int running = 0;
int ready = 0;
int blocked = 0;
int terminated = 0;
int future = 0;
unsigned int closest = 0;
vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
for(; it != _dynamic_threads.end(); it++)
{
if ((**it).get_state() == state_running) running++;
if ((**it).get_state() == state_ready) ready++;
if ((**it).get_state() == state_blocked) blocked++;
if ((**it).get_state() == state_terminated) terminated++;
if ((**it).get_state() == state_future)
{
unsigned int arrival = (**it).get_arrival_time();
// if this is the first future occurrence, record its arrival;
// else record its arrival if and only if it is smaller then the recorded one
if (future == 0)
closest = arrival;
else
closest = (closest < arrival) ? closest : arrival;
future++;
}
}
unsigned int closest = 0;
assert(total > 0);
assert(running == 1 || running == 0);
assert(running + ready + blocked + terminated + future == total);
vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
for (; it != _dynamic_threads.end(); it++)
{
if ((**it).get_state() == state_running) running++;
if ((**it).get_state() == state_ready) ready++;
if ((**it).get_state() == state_blocked) blocked++;
if ((**it).get_state() == state_terminated) terminated++;
if ((**it).get_state() == state_future)
{
unsigned int arrival = (**it).get_arrival_time();
// if this is the first future occurrence, record its arrival;
// else record its arrival if and only if it is smaller then the recorded one
if (future == 0)
closest = arrival;
else
closest = (closest < arrival) ? closest : arrival;
future++;
}
}
if (running > 0)
return state_running;
if (ready > 0) // running == 0
return state_ready;
if (blocked > 0) // running == 0 && ready == 0
return state_blocked;
// Now check if a "hole" happens: if all threads are terminated
// or blocked the next
// thread to start, e.g. the one with the least arrival_time, has
// start time greater than the current process elapsed time, then
// pass from state_future to state_terminated:
if (closest > get_elapsed_time())
return state_terminated;
if (terminated > 0) // running == 0 && ready == 0 && blocked == 0
return state_terminated;
if (future > 0) // running == 0 && ready == 0 && blocked == 0 && terminated == 0
return state_future;
assert(total > 0);
assert(running == 1 || running == 0);
assert(running + ready + blocked + terminated + future == total);
// I'm not sure if we can get here (maybe if there are no threads?),
// but I don't like this compiler warning: 'control reaches end of non-void function'
if (running > 0)
return state_running;
if (ready > 0) // running == 0
return state_ready;
if (blocked > 0) // running == 0 && ready == 0
return state_blocked;
// Now check if a "hole" happens: if all threads are terminated
// or blocked the next
// thread to start, e.g. the one with the least arrival_time, has
// start time greater than the current process elapsed time, then
// pass from state_future to state_terminated:
if (closest > get_elapsed_time())
return state_terminated;
if (terminated > 0) // running == 0 && ready == 0 && blocked == 0
return state_terminated;
if (future > 0) // running == 0 && ready == 0 && blocked == 0 && terminated == 0
return state_future;
// Since premature optimization is the root of all evil, and the
// following code was very fast but also very wrong, the coder
// will be punished by allowing her to code in C++ just after
// having passed "Algoritmi 3" exam with full marks.
// I'm not sure if we can get here (maybe if there are no threads?),
// but I don't like this compiler warning: 'control reaches end of non-void function'
return state_future;
// Since premature optimization is the root of all evil, and the
// following code was very fast but also very wrong, the coder
// will be punished by allowing her to code in C++ just after
// having passed "Algoritmi 3" exam with full marks.
/*
typedef vector<DynamicThread*>::const_iterator ThreadIt;
@ -164,7 +164,7 @@ DynamicProcess::get_state() const
// TODO Is this OK? Must be tested...
int thread_starts_at;
switch(thread_state)
{
@ -189,8 +189,8 @@ DynamicProcess::get_state() const
}
} //~ "for" iterating over threads
// reused hole checking system
*/
// reused hole checking system
*/
}
@ -204,32 +204,32 @@ DynamicProcess::serialize(SerializeVisitor& translator) const
StaticProcess&
DynamicProcess::get_core()
{
return *_core;
return *_core;
}
const StaticProcess&
DynamicProcess::get_core() const
{
return *_core;
return *_core;
}
std::vector<DynamicThread*>&
DynamicProcess::get_dynamic_threads()
{
return _dynamic_threads;
return _dynamic_threads;
}
unsigned int
DynamicProcess::get_elapsed_time() const
{
unsigned int result = 0;
for(std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
result += (*it)->get_elapsed_time();
}
for (std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
result += (*it)->get_elapsed_time();
}
return result;
}
@ -237,13 +237,13 @@ int
DynamicProcess::get_last_acquisition() const
{
int result = -1;
for(std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
int acq = (*it)->get_last_acquisition();
if(result < acq)
result = acq;
}
for (std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
int acq = (*it)->get_last_acquisition();
if (result < acq)
result = acq;
}
return result;
}
@ -251,13 +251,13 @@ int
DynamicProcess::get_last_release() const
{
int result = -1;
for(std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
int acq = (*it)->get_last_release();
if(result < acq)
result = acq;
}
for (std::vector<DynamicThread*>::const_iterator it = _dynamic_threads.begin();
it != _dynamic_threads.end(); it++)
{
int acq = (*it)->get_last_release();
if (result < acq)
result = acq;
}
return result;
}

6
src/backend/dynamic_process.hh
View file

@ -45,7 +45,7 @@ namespace sgpem
public:
DynamicProcess(StaticProcess* core);
DynamicProcess(const DynamicProcess &other);
virtual ~DynamicProcess();
virtual ~DynamicProcess();
std::vector<Thread*> get_threads();
std::vector<const Thread*> get_threads() const;
@ -61,8 +61,8 @@ namespace sgpem
virtual StaticProcess& get_core();
virtual const StaticProcess& get_core() const;
// Does also the job of "add_thread" and "remove_thread"
std::vector<DynamicThread*>& get_dynamic_threads();
// Does also the job of "add_thread" and "remove_thread"
std::vector<DynamicThread*>& get_dynamic_threads();
private:
memory::smart_ptr<StaticProcess> _core;

76
src/backend/dynamic_request.cc
View file

@ -47,38 +47,38 @@ DynamicRequest::DynamicRequest(StaticRequest *core,
}
DynamicRequest::DynamicRequest(const DynamicRequest& other, DynamicThread* owner) :
_static_request(other._static_request), _dynamic_thread(owner)
_static_request(other._static_request), _dynamic_thread(owner)
{
typedef vector<DynamicSubRequest*> SubReqVec;
assert(owner != NULL);
const SubReqVec& other_subs = other._dynamic_subrequests;
// Not sure of this, but the constructor of DynamicSubRequest should take care
// of adding itself to the vector of sub requests. This is only my opinion,
// of adding itself to the vector of sub requests. This is only my opinion,
// but I think this is a complicated way of doing things...
for(SubReqVec::const_iterator it = other_subs.begin(); it != other_subs.end(); ++it)
for (SubReqVec::const_iterator it = other_subs.begin(); it != other_subs.end(); ++it)
new DynamicSubRequest(*(*it), this);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicRequest*>& siblings = owner->get_dynamic_requests();
siblings.push_back(this);
}
DynamicRequest::~DynamicRequest()
{
for_each(_dynamic_subrequests.begin(), _dynamic_subrequests.end(),
memory::deletor<DynamicSubRequest>());
for_each(_dynamic_subrequests.begin(), _dynamic_subrequests.end(),
memory::deletor<DynamicSubRequest>());
}
bool
DynamicRequest::operator==(const Request& op2) const
{
assert(dynamic_cast<const DynamicRequest*>(&op2) != NULL);
assert(dynamic_cast<const DynamicRequest*>(&op2) != NULL);
return _static_request == dynamic_cast<const DynamicRequest&>(op2)._static_request;
}
@ -112,42 +112,42 @@ DynamicRequest::get_instant() const
Request::state
DynamicRequest::get_state() const
{
typedef std::vector<DynamicSubRequest*> SubReqs;
typedef std::vector<DynamicSubRequest*> SubReqs;
state result = state_future;
state result = state_future;
#ifndef NDEBUG
// Only for debug:
bool at_least_once = false;
// Only for debug:
bool at_least_once = false;
#endif // ~NDEBUG
const SubReqs& sreqs = _dynamic_subrequests;
for(SubReqs::const_iterator it = sreqs.begin(); it != sreqs.end(); it++)
{
SubRequest& cur = **it;
const SubReqs& sreqs = _dynamic_subrequests;
for (SubReqs::const_iterator it = sreqs.begin(); it != sreqs.end(); it++)
{
SubRequest& cur = **it;
switch(cur.get_state())
{
case state_allocated:
return state_allocated;
case state_unallocable:
return state_unallocable;
default:
switch (cur.get_state())
{
case state_allocated:
return state_allocated;
case state_unallocable:
return state_unallocable;
default:
#ifndef NDEBUG
// We want to be sure that all subrequests
// have the same state since state_allocable,
// state_terminated and state_future are mutually
// exclusive
if(at_least_once)
assert(result == cur.get_state());
at_least_once = true;
// We want to be sure that all subrequests
// have the same state since state_allocable,
// state_terminated and state_future are mutually
// exclusive
if (at_least_once)
assert(result == cur.get_state());
at_least_once = true;
#endif //~ NDEBUG
result = cur.get_state();
}
}
return result;
result = cur.get_state();
}
}
return result;
}
@ -161,12 +161,12 @@ DynamicRequest::serialize(SerializeVisitor& translator) const
StaticRequest&
DynamicRequest::get_core()
{
return *_static_request;
return *_static_request;
}
const StaticRequest&
DynamicRequest::get_core() const
{
return *_static_request;
return *_static_request;
}

16
src/backend/dynamic_request.hh
View file

@ -43,11 +43,11 @@ namespace sgpem
public:
DynamicRequest(StaticRequest *core, DynamicThread* owner);
DynamicRequest(const DynamicRequest& other, DynamicThread* owner);
~DynamicRequest();
~DynamicRequest();
virtual bool operator==(const Request& op2) const;
virtual bool operator==(const Request& op2) const;
virtual std::vector<SubRequest*> get_subrequests();
virtual std::vector<SubRequest*> get_subrequests();
DynamicThread& get_thread();
@ -57,12 +57,12 @@ namespace sgpem
void serialize(SerializeVisitor& translator) const;
StaticRequest& get_core();
const StaticRequest& get_core() const;
StaticRequest& get_core();
const StaticRequest& get_core() const;
// Since this method is visible only by the backend,
// return directly a reference that lets us to
// add and remove subrequests at will.
// Since this method is visible only by the backend,
// return directly a reference that lets us to
// add and remove subrequests at will.
std::vector<DynamicSubRequest*>& get_dynamic_subrequests();
private:

6
src/backend/dynamic_resource.cc
View file

@ -36,7 +36,7 @@ DynamicResource::DynamicResource(StaticResource *core) :
bool
DynamicResource::operator==(const Resource& op2) const
{
assert(dynamic_cast<const DynamicResource*>(&op2) != NULL);
assert(dynamic_cast<const DynamicResource*>(&op2) != NULL);
return _static_resource == dynamic_cast<const DynamicResource&>(op2)._static_resource;
}
@ -62,12 +62,12 @@ DynamicResource::serialize(SerializeVisitor& translator) const
StaticResource&
DynamicResource::get_core()
{
return *_static_resource;
return *_static_resource;
}
const StaticResource&
DynamicResource::get_core() const
{
return *_static_resource;
return *_static_resource;
}

6
src/backend/dynamic_resource.hh
View file

@ -39,15 +39,15 @@ namespace sgpem
public:
DynamicResource(StaticResource *core);
virtual bool operator==(const Resource& op2) const;
virtual bool operator==(const Resource& op2) const;
Glib::ustring get_name() const;
unsigned int get_places() const;
void serialize(SerializeVisitor& translator) const;
StaticResource& get_core();
const StaticResource& get_core() const;
StaticResource& get_core();
const StaticResource& get_core() const;
private:
memory::smart_ptr<StaticResource> _static_resource;

8
src/backend/dynamic_schedulable.cc
View file

@ -27,14 +27,14 @@
using namespace sgpem;
using namespace std;
DynamicSchedulable::DynamicSchedulable()
: _priority_push(0)
DynamicSchedulable::DynamicSchedulable()
: _priority_push(0)
{}
bool
DynamicSchedulable::operator==(const Schedulable& op2) const
{
assert(dynamic_cast<const DynamicSchedulable*>(&op2) != NULL);
assert(dynamic_cast<const DynamicSchedulable*>(&op2) != NULL);
return &get_core() == &(dynamic_cast<const DynamicSchedulable&>(op2).get_core());
}
@ -62,7 +62,7 @@ DynamicSchedulable::get_total_cpu_time() const
return get_core().get_total_cpu_time();
}
int
int
DynamicSchedulable::set_priority_push(int new_value)
{
int old_priority_push = _priority_push;

73
src/backend/dynamic_sub_request.cc
View file

@ -30,42 +30,41 @@
using namespace sgpem;
DynamicSubRequest::DynamicSubRequest(StaticSubRequest* core,
DynamicRequest* owner) :
_static_subrequest(core), _owner(owner),
_queue_position(-1), _ran_for(0), _state(Request::state_future)
DynamicSubRequest::DynamicSubRequest(StaticSubRequest* core,
DynamicRequest* owner) :
_static_subrequest(core), _owner(owner),
_queue_position(-1), _ran_for(0), _state(Request::state_future)
{
assert(core != NULL);
assert(owner != NULL);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicSubRequest*>& siblings = owner->get_dynamic_subrequests();
siblings.push_back(this);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicSubRequest*>& siblings = owner->get_dynamic_subrequests();
siblings.push_back(this);
}
DynamicSubRequest::DynamicSubRequest(const DynamicSubRequest& other,
DynamicSubRequest::DynamicSubRequest(const DynamicSubRequest& other,
DynamicRequest* owner) :
_static_subrequest(other._static_subrequest), _owner(owner),
_queue_position(other._queue_position), _ran_for(other._ran_for),
_state(other._state)
_static_subrequest(other._static_subrequest), _owner(owner),
_queue_position(other._queue_position), _ran_for(other._ran_for),
_state(other._state)
{
assert(owner != NULL);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicSubRequest*>& siblings = owner->get_dynamic_subrequests();
siblings.push_back(this);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicSubRequest*>& siblings = owner->get_dynamic_subrequests();
siblings.push_back(this);
}
DynamicSubRequest::~DynamicSubRequest()
{
}
{}
bool
DynamicSubRequest::operator==(const SubRequest& op2) const
{
assert(dynamic_cast<const DynamicSubRequest*>(&op2) != NULL);
assert(dynamic_cast<const DynamicSubRequest*>(&op2) != NULL);
return _static_subrequest == dynamic_cast<const DynamicSubRequest&>(op2)._static_subrequest;
}
@ -99,42 +98,42 @@ DynamicSubRequest::set_queue_position(int position)
DynamicRequest&
DynamicSubRequest::get_request()
{
return *_owner;
return *_owner;
}
DynamicSubRequest::state
DynamicSubRequest::get_state() const
{
return _state;
return _state;
}
DynamicSubRequest::state
DynamicSubRequest::set_state(state new_state)
{
state temp = _state;
_state = new_state;
return temp;
state temp = _state;
_state = new_state;
return temp;
}
unsigned int
unsigned int
DynamicSubRequest::get_remaining_time() const
{
return _static_subrequest->get_length() - _ran_for;
return _static_subrequest->get_length() - _ran_for;
}
unsigned int
DynamicSubRequest::decrease_remaining_time()
{
assert(_state == Request::state_allocated);
unsigned int temp = get_remaining_time();
if(temp > 0)
_ran_for++;
return temp;
assert(_state == Request::state_allocated);
unsigned int temp = get_remaining_time();
if (temp > 0)
_ran_for++;
return temp;
}
@ -145,15 +144,15 @@ DynamicSubRequest::serialize(SerializeVisitor& translator) const
}
StaticSubRequest&
StaticSubRequest&
DynamicSubRequest::get_core()
{
return *_static_subrequest;
return *_static_subrequest;
}
const StaticSubRequest&
const StaticSubRequest&
DynamicSubRequest::get_core() const
{
return *_static_subrequest;
return *_static_subrequest;
}

34
src/backend/dynamic_sub_request.hh
View file

@ -34,20 +34,20 @@
namespace sgpem
{
class DynamicSubRequest;
class SerializeVisitor;
class SerializeVisitor;
class Resource;
class StaticSubRequest;
class SG_DLLLOCAL DynamicSubRequest : public SubRequest
{
public:
DynamicSubRequest(StaticSubRequest* core,
DynamicRequest* owner);
public:
DynamicSubRequest(StaticSubRequest* core,
DynamicRequest* owner);
DynamicSubRequest(const DynamicSubRequest& other, DynamicRequest* owner);
virtual ~DynamicSubRequest();
virtual ~DynamicSubRequest();
virtual bool operator==(const SubRequest& op2) const;
virtual bool operator==(const SubRequest& op2) const;
resource_key_t get_resource_key() const;
@ -56,28 +56,28 @@ namespace sgpem
int get_queue_position() const;
void set_queue_position(int position);
virtual DynamicRequest& get_request();
virtual DynamicRequest& get_request();
state get_state() const;
state set_state(state new_state);
unsigned int get_remaining_time() const;
unsigned int decrease_remaining_time();
state get_state() const;
state set_state(state new_state);
unsigned int get_remaining_time() const;
unsigned int decrease_remaining_time();
void serialize(SerializeVisitor& translator) const;
StaticSubRequest& get_core();
const StaticSubRequest& get_core() const;
StaticSubRequest& get_core();
const StaticSubRequest& get_core() const;
private:
// Undefined
DynamicSubRequest(const DynamicSubRequest&);
memory::smart_ptr<StaticSubRequest> _static_subrequest;
DynamicRequest* _owner;
DynamicRequest* _owner;
int _queue_position;
unsigned int _ran_for;
state _state;
unsigned int _ran_for;
state _state;
};
}

46
src/backend/dynamic_thread.cc
View file

@ -34,32 +34,32 @@ using namespace sgpem;
using namespace std;
DynamicThread::DynamicThread(StaticThread* core, DynamicProcess* parent)
: DynamicSchedulable(), _core(core), _state(state_future), _parent(parent),
DynamicThread::DynamicThread(StaticThread* core, DynamicProcess* parent)
: DynamicSchedulable(), _core(core), _state(state_future), _parent(parent),
_ran_for(0), _last_acquisition(-1), _last_release(-1)
{
assert(core != NULL);
assert(parent != NULL);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicThread*>& siblings = parent->get_dynamic_threads();
siblings.push_back(this);
assert(core != NULL);
assert(parent != NULL);
// Leave this line: it helps us with a compiler warning if
// the get_dynamic* method signature changes:
std::vector<DynamicThread*>& siblings = parent->get_dynamic_threads();
siblings.push_back(this);
}
DynamicThread::DynamicThread(const DynamicThread &other, DynamicProcess* parent) :
Schedulable(), DynamicSchedulable(other), Thread(),
_core(other._core), _state(other._state), _parent(parent),
_ran_for(other._ran_for), _last_acquisition(other._last_acquisition),
Schedulable(), DynamicSchedulable(other), Thread(),
_core(other._core), _state(other._state), _parent(parent),
_ran_for(other._ran_for), _last_acquisition(other._last_acquisition),
_last_release(other._last_release)
{
typedef vector<DynamicRequest*>::const_iterator ReqIt;
assert(parent != NULL);
const vector<DynamicRequest*>& other_req = other._dynamic_requests;
for(ReqIt it = other_req.begin(); it != other_req.end(); ++it)
for (ReqIt it = other_req.begin(); it != other_req.end(); ++it)
new DynamicRequest(*(*it), this);
// Leave this line: it helps us with a compiler warning if
@ -70,8 +70,8 @@ DynamicThread::DynamicThread(const DynamicThread &other, DynamicProcess* parent)
DynamicThread::~DynamicThread()
{
for_each(_dynamic_requests.begin(), _dynamic_requests.end(),
memory::deletor<DynamicRequest>());
for_each(_dynamic_requests.begin(), _dynamic_requests.end(),
memory::deletor<DynamicRequest>());
}
@ -112,20 +112,20 @@ DynamicThread::serialize(SerializeVisitor& translator) const
StaticThread&
DynamicThread::get_core()
{
return *_core;
return *_core;
}
const StaticThread&
DynamicThread::get_core() const
{
return *_core;
return *_core;
}
std::vector<DynamicRequest*>&
DynamicThread::get_dynamic_requests()
{
return _dynamic_requests;
return _dynamic_requests;
}
@ -138,10 +138,10 @@ DynamicThread::get_elapsed_time() const
void
DynamicThread::decrease_remaining_time()
{
// strict check for us to better debug scheduler
assert(_ran_for < get_total_cpu_time());
if(_ran_for < get_total_cpu_time())
_ran_for++;
// strict check for us to better debug scheduler
assert(_ran_for < get_total_cpu_time());
if (_ran_for < get_total_cpu_time())
_ran_for++;
}
int

4
src/backend/dynamic_thread.hh
View file

@ -72,9 +72,9 @@ namespace sgpem
std::vector<DynamicRequest*>& get_dynamic_requests();
private:
// Undefined
// Undefined
DynamicThread(const DynamicThread &other);
memory::smart_ptr<StaticThread> _core;
state _state;
std::vector<DynamicRequest*> _dynamic_requests;

18
src/backend/environment.hh
View file

@ -38,7 +38,7 @@ namespace sgpem
/// \brief An instant of the simulation.
/// An object of the Environment class represents a snapshot of
/// the simulated environment taken in a fixed instant, composed
/// the simulated environment taken in a fixed instant, composed
/// by processes, threads, resources and more.
/// A snapshot for every single entity is accessible from here.
/// All the provided objects and data is constant.
@ -58,11 +58,11 @@ namespace sgpem
class SG_DLLEXPORT Environment
{
public:
typedef SubRequest::resource_key_t resource_key_t;
typedef SubRequest::resource_key_t resource_key_t;
typedef std::vector<Process*> Processes;
typedef std::map<resource_key_t, Resource*> Resources;
typedef std::vector<SubRequest*> SubRequestQueue;
typedef std::vector<Process*> Processes;
typedef std::map<resource_key_t, Resource*> Resources;
typedef std::vector<SubRequest*> SubRequestQueue;
/// \brief Returns an indexed set of snapshots of the processes
/// Returns a standard vector of Process objects describing
@ -72,7 +72,7 @@ namespace sgpem
/// \return a constant set of snapshots of processes
virtual const Processes&
get_processes() const = 0;
get_processes() const = 0;
/// \brief Returns an indexed set of snapshots of the resources
@ -90,7 +90,7 @@ namespace sgpem
/// \return an indexed constant set of snapshot of resources.
virtual const Resources&
get_resources() const = 0;
get_resources() const = 0;
/// \brief Returns a snapshot of the current request queue for a resource.
@ -101,7 +101,7 @@ namespace sgpem
/// \return the current ready requests queue (constant).
virtual const SubRequestQueue&
get_request_queue(resource_key_t resource_key) const = 0;
get_request_queue(resource_key_t resource_key) const = 0;
/// \brief Returns a snapshot of the current scheduler's ready queue.
@ -112,7 +112,7 @@ namespace sgpem
/// \return the current ready queue (constant).
virtual const ReadyQueue&
get_sorted_queue() const = 0;
get_sorted_queue() const = 0;
/// \brief The standard virtual destructor.

49
src/backend/global_preferences.cc
View file

@ -96,13 +96,13 @@ GlobalPreferences::get_plugin_dirs()
return _mod_dirs;
}
int
int
GlobalPreferences::get_speed()
{
return _speed;
}
int
int
GlobalPreferences::set_speed(int new_speed)
{
int old_speed = _speed;
@ -123,7 +123,7 @@ void
GlobalPreferences::load_configrc()
{
KeyFile kf;
kf.file_read(get_config_filename());
key_file_read(kf);
}
@ -141,7 +141,7 @@ void
GlobalPreferences::load_configrc(std::istream &is)
{
KeyFile kf;
kf.file_read(is);
key_file_read(kf);
}
@ -157,7 +157,8 @@ GlobalPreferences::key_file_read(KeyFile& kf)
{
int new_speed;
const Glib::ustring* val = kf.search_value(Glib::ustring("speed"));
if(val){
if (val)
{
string_to_int(*val, new_speed);
set_speed(new_speed);
}
@ -165,18 +166,18 @@ GlobalPreferences::key_file_read(KeyFile& kf)
// read modules directories
{
const Glib::ustring* val = kf.search_value(Glib::ustring("modules-dir-number"));
if(val)
if (val)
{
std::istringstream istr(val->c_str());
int n;
istr >> n;
for(int i=1; i<=n; i++)
for (int i = 1; i <= n; i++)
{
std::ostringstream ostr;
ostr << "modules-dir-" << i;
Glib::ustring key(ostr.str());
val = kf.search_value(key);
if(val)
if (val)
{
// add_modules_dir(*val);
_mod_dirs.push_back(*val);
@ -188,18 +189,18 @@ GlobalPreferences::key_file_read(KeyFile& kf)
// read policies directories
{
const Glib::ustring* val = kf.search_value(Glib::ustring("policies-dir-number"));
if(val)
if (val)
{
std::istringstream istr(val->c_str());
int n;
istr >> n;
for(int i=1; i<=n; i++)
for (int i = 1; i <= n; i++)
{
std::ostringstream ostr;
ostr << "policies-dir-" << i;
ostr << "policies-dir-" << i;
Glib::ustring key(ostr.str());
val = kf.search_value(key);
if(val)
if (val)
{
// add_policies_dir(*val);
_pol_dirs.push_back(*val);
@ -227,10 +228,11 @@ GlobalPreferences::key_file_write(KeyFile& kf)
/*
GlobalPreferences::dir_iterator iter=_globalPreferences.modules_dir_begin();
*/
dir_iterator iter=_mod_dirs.begin();
dir_iterator end=_mod_dirs.end();
int n=0;
while(iter!=end){
dir_iterator iter = _mod_dirs.begin();
dir_iterator end = _mod_dirs.end();
int n = 0;
while (iter != end)
{
std::ostringstream ostr;
n++;
ostr << "modules-dir-" << n; // << std::ends;
@ -246,13 +248,14 @@ GlobalPreferences::key_file_write(KeyFile& kf)
}
// add policies directories
{
/*
GlobalPreferences::dir_iterator iter=_globalPreferences.policies_dir_begin();
*/
dir_iterator iter=_pol_dirs.begin();
dir_iterator end=_pol_dirs.end();
int n=0;
while(iter!=end){
/*
GlobalPreferences::dir_iterator iter=_globalPreferences.policies_dir_begin();
*/
dir_iterator iter = _pol_dirs.begin();
dir_iterator end = _pol_dirs.end();
int n = 0;
while (iter != end)
{
std::ostringstream ostr;
n++;
ostr << "policies-dir-" << n; // << std::ends;

22
src/backend/global_preferences.hh
View file

@ -49,25 +49,25 @@ namespace sgpem
public:
typedef std::vector<Glib::ustring>::const_iterator dir_iterator;
dir_iterator modules_dir_begin() const;
dir_iterator modules_dir_end() const;
dir_iterator policies_dir_begin() const;
dir_iterator policies_dir_end() const;
/**
\return GlobalPreferences configuration filename
*/
const Glib::ustring get_config_filename();
/**
\brief Adds a directory search entry to modules dirs
*/
void add_modules_dir(const Glib::ustring& moddir);
/**
\brief Adds a directory search entry to policies dirs
*/
@ -75,14 +75,14 @@ namespace sgpem
/**
\brief Returns configured Policy directories
\return ::_policy_dirs
*/
std::vector<Glib::ustring>& get_policy_dirs();
/**
\brief Returns configured Plugin directories
\return ::_plugin_dirs
*/
std::vector<Glib::ustring>& get_plugin_dirs();
@ -93,14 +93,14 @@ namespace sgpem
\return _speed
*/
int get_speed();
/**
\brief Returns the simumulation speed and return old speed
\return _speed
*/
int set_speed(int new_speed);
/**
\brief Writes preferences to disk
@ -122,7 +122,7 @@ namespace sgpem
\throw std::io_error
*/
void load_configrc();
void write_configrc(std::ostream &os);
void load_configrc(std::istream &is);
private:
@ -148,7 +148,7 @@ namespace sgpem
-# Via command line arguments
-# By a backend::Plugin::on_init() method called when loading an external DSO. This is perfectly normal and permitted.
*/
int _speed;
};
}

38
src/backend/global_preferences_serializer.cc
View file

@ -27,11 +27,11 @@ namespace sgpem
{
GlobalPreferencesSerializer::GlobalPreferencesSerializer(GlobalPreferences &gp)
: _globalPreferences(gp)
: _globalPreferences(gp)
{}
void
GlobalPreferencesSerializer::file_read(const Glib::ustring& filename)
{
@ -41,18 +41,18 @@ namespace sgpem
// read modules directories
{
const Glib::ustring* val = search_value(Glib::ustring("modules-dir-number"));
if(val)
if (val)
{
std::istringstream istr(val->c_str());
int n;
istr >> n;
for(int i=1; i<=n; i++)
for (int i = 1; i <= n; i++)
{
std::ostringstream ostr;
ostr << "modules-dir-" << i << std::ends;
Glib::ustring key(ostr.str());
val = search_value(key);
if(val)
if (val)
{
_globalPreferences.add_modules_dir(*val);
}
@ -63,18 +63,18 @@ namespace sgpem
// read policies directories
{
const Glib::ustring* val = search_value(Glib::ustring("policies-dir-number"));
if(val)
if (val)
{
std::istringstream istr(val->c_str());
int n;
istr >> n;
for(int i=1; i<=n; i++)
for (int i = 1; i <= n; i++)
{
std::ostringstream ostr;
ostr << "policies-dir-" << i << std::ends;
Glib::ustring key(ostr.str());
val = search_value(key);
if(val)
if (val)
{
_globalPreferences.add_policies_dir(*val);
}
@ -82,15 +82,16 @@ namespace sgpem
}
}
}
void
GlobalPreferencesSerializer::file_write(const Glib::ustring& filename)
{
// add modules directories
{
GlobalPreferences::dir_iterator iter=_globalPreferences.modules_dir_begin();
int n=0;
while(iter!=_globalPreferences.modules_dir_end()){
GlobalPreferences::dir_iterator iter = _globalPreferences.modules_dir_begin();
int n = 0;
while (iter != _globalPreferences.modules_dir_end())
{
std::ostringstream ostr;
n++;
ostr << "modules-dir-" << n << std::ends;
@ -106,9 +107,10 @@ namespace sgpem
}
// add policies directories
{
GlobalPreferences::dir_iterator iter=_globalPreferences.policies_dir_begin();
int n=0;
while(iter!=_globalPreferences.policies_dir_end()){
GlobalPreferences::dir_iterator iter = _globalPreferences.policies_dir_begin();
int n = 0;
while (iter != _globalPreferences.policies_dir_end())
{
std::ostringstream ostr;
n++;
ostr << "policies-dir-" << n << std::ends;
@ -122,7 +124,7 @@ namespace sgpem
Glib::ustring value(ostr.str());
insert_key_value(key, value);
}
KeyFile::file_write(filename);
}
}

2
src/backend/global_preferences_serializer.hh
View file

@ -29,7 +29,7 @@ namespace sgpem
class GlobalPreferencesSerializer;
/** \brief Save and retrieve global preferences formatted as key=value rows.
*
* This class handles files to store and retrieve global preferences

30
src/backend/history.cc
View file

@ -30,40 +30,38 @@ using namespace std;
History::History()
: _notify(true)
{
}
: _notify(true)
{}
History::~History()
{
}
{}
void
History::attach(HistoryObserver& observer)
{
_observers.push_back(&observer);
_observers.push_back(&observer);
}
void
History::detach(const HistoryObserver& observer)
{
_observers.erase(std::find(_observers.begin(),
_observers.end(),
&observer));
_observers.erase(std::find(_observers.begin(),
_observers.end(),
&observer));
}
void
void
History::notify_change()
{
if(!_notify) return;
if (!_notify) return;
for(RegisteredObservers::iterator it =_observers.begin();
it != _observers.end(); it++)
(*it)->update(*this);
for (RegisteredObservers::iterator it = _observers.begin();
it != _observers.end(); it++)
(*it)->update(*this);
}
@ -72,9 +70,9 @@ History::set_notify_enabled(bool enabled)
{
bool old_value = _notify;
_notify = enabled;
// Force notify if we re-enable it
if(old_value == false && _notify == true)
if (old_value == false && _notify == true)
notify_change();
return old_value;

99
src/backend/history.hh
View file

@ -45,64 +45,64 @@ namespace sgpem
*/
class History;
// Forward declarations:
class HistoryObserver;
class Resource;
class Process;
class Thread;
class Request;
class SubRequest;
// Forward declarations:
class HistoryObserver;
class Resource;
class Process;
class Thread;
class Request;
class SubRequest;
class SG_DLLEXPORT History
{
public:
typedef unsigned int size_t;
typedef unsigned int time_t;
typedef unsigned int position;
typedef int prio_t;
typedef unsigned int size_t;
typedef unsigned int time_t;
typedef unsigned int position;
typedef int prio_t;
typedef Environment::resource_key_t resource_key_t;
typedef const std::pair<resource_key_t, Resource*> ResourcePair;
typedef Environment::resource_key_t resource_key_t;
typedef const std::pair<resource_key_t, Resource*> ResourcePair;
History();
virtual ~History() = 0;
virtual size_t get_size() const = 0;
virtual const Environment& get_last_environment() const = 0;
virtual const Environment& get_environment_at(position index) const throw(std::out_of_range) = 0;
virtual void remove(resource_key_t resource_key) = 0;
virtual void remove(Process& process) = 0;
virtual void remove(Thread& thread) = 0;
virtual void remove(Request& request) = 0;
virtual void remove(SubRequest& subrequest) = 0;
virtual ~History() = 0;
virtual size_t get_size() const = 0;
virtual const Environment& get_last_environment() const = 0;
virtual const Environment& get_environment_at(position index) const throw(std::out_of_range) = 0;
virtual void remove(resource_key_t resource_key) = 0;
virtual void remove(Process& process) = 0;
virtual void remove(Thread& thread) = 0;
virtual void remove(Request& request) = 0;
virtual void remove(SubRequest& subrequest) = 0;
virtual ResourcePair add_resource(const Glib::ustring& name,
bool preemptable = false,
size_t places = 1,
size_t availability = 0) = 0;
virtual ResourcePair add_resource(const Glib::ustring& name,
bool preemptable = false,
size_t places = 1,
size_t availability = 0) = 0;
virtual Process& add_process(const Glib::ustring& name,
time_t arrival_time,
prio_t base_priority = 0) = 0;
virtual Process& add_process(const Glib::ustring& name,
time_t arrival_time,
prio_t base_priority = 0) = 0;
virtual Thread& add_thread(const Glib::ustring& name,
Process& parent,
time_t cpu_time,
time_t arrival_time = 0,
prio_t base_priority = 0) = 0;
virtual Thread& add_thread(const Glib::ustring& name,
Process& parent,
time_t cpu_time,
time_t arrival_time = 0,
prio_t base_priority = 0) = 0;
virtual Request& add_request(Thread& owner,
time_t instant) = 0;
virtual Request& add_request(Thread& owner,
time_t instant) = 0;
virtual SubRequest& add_subrequest(Request& request,
resource_key_t resource_key,
time_t duration) = 0;
virtual SubRequest& add_subrequest(Request& request,
resource_key_t resource_key,
time_t duration) = 0;
virtual void attach(HistoryObserver& observer);
virtual void detach(const HistoryObserver& observer);
virtual void attach(HistoryObserver& observer);
virtual void detach(const HistoryObserver& observer);
/** \brief Enable/disable notifications to registered observers
*
@ -113,17 +113,18 @@ namespace sgpem
* \return The old value
*/
virtual bool set_notify_enabled(bool enabled = true);
protected:
typedef std::vector<HistoryObserver*> RegisteredObservers;
RegisteredObservers _observers;
virtual void notify_change();
protected:
typedef std::vector<HistoryObserver*> RegisteredObservers;
RegisteredObservers _observers;
virtual void notify_change();
private:
bool _notify;
}; //~ class History
}
; //~ class History
}//~ namespace sgpem

9
src/backend/history_observer.hh
View file

@ -25,16 +25,17 @@
namespace sgpem
{
class History;
class History;
class HistoryObserver;
class SG_DLLEXPORT HistoryObserver
{
public:
virtual void update(const History& changed_history) = 0;
virtual ~HistoryObserver();
virtual void update(const History& changed_history) = 0;
virtual ~HistoryObserver();
}; // class HistoryObserver
}
; // class HistoryObserver
}//~ namespace sgpem

34
src/backend/holt_graph.cc
View file

@ -27,7 +27,7 @@
using namespace sgpem;
using namespace std;
void
void
HoltGraph::update(const History& changed_history)
{
const Environment& env = changed_history.get_last_environment();
@ -36,33 +36,33 @@ HoltGraph::update(const History& changed_history)
_resources.clear();
_active_threads.clear();
_active_requests.clear();
for(unsigned int pi = 0; pi < processes.size(); ++pi)
for (unsigned int pi = 0; pi < processes.size(); ++pi)
{
vector<Thread*> threads = processes[pi]->get_threads();
for(unsigned int ti = 0; ti < threads.size(); ++ti)
for (unsigned int ti = 0; ti < threads.size(); ++ti)
{
vector<Request*> requests = threads[ti]->get_requests();
for(unsigned int ri = 0; ri < requests.size(); ++ri)
for (unsigned int ri = 0; ri < requests.size(); ++ri)
{
Request& r = *requests[ri];
Request& r = *requests[ri];
if(r.get_state() == Request::state_allocated)
{
_active_requests.push_back(&r);
_active_threads.insert(&r.get_thread());
if (r.get_state() == Request::state_allocated)
{
_active_requests.push_back(&r);
_active_threads.insert(&r.get_thread());
vector<SubRequest*> subrequests = r.get_subrequests();
vector<SubRequest*> subrequests = r.get_subrequests();
for(unsigned int sri = 0; sri < subrequests.size(); ++sri)
{
Environment::resource_key_t key = subrequests[sri]->get_resource_key();
for (unsigned int sri = 0; sri < subrequests.size(); ++sri)
{
Environment::resource_key_t key = subrequests[sri]->get_resource_key();
_resources.insert(env.get_resources().find(key)->second);
}
}
_resources.insert(env.get_resources().find(key)->second);
}
}
}
}
}

7
src/backend/holt_graph.hh
View file

@ -43,9 +43,9 @@ namespace sgpem
typedef std::vector<const Resource*> Resources;
typedef std::vector<const Thread*> Threads;
typedef std::vector<const Request*> Requests;
HoltGraph();
virtual void update(const History& changed_history);
Resources get_resources() const;
@ -56,7 +56,8 @@ namespace sgpem
std::set<const Resource*> _resources;
std::set<const Thread*> _active_threads;
Requests _active_requests;
}; // class HistoryObserver
}
; // class HistoryObserver
}//~ namespace sgpem

5
src/backend/invalid_plugin_exception.cc
View file

@ -25,6 +25,5 @@
using namespace sgpem;
InvalidPluginException::InvalidPluginException(const std::string& what) :
std::runtime_error(what)
{
}
std::runtime_error(what)
{}

3
src/backend/invalid_plugin_exception.hh
View file

@ -31,7 +31,8 @@ namespace sgpem
{
public:
InvalidPluginException(const std::string& what);
}; //~ class InvalidPluginException
}
; //~ class InvalidPluginException
} //~ namespace sgpem

45
src/backend/key_file.cc
View file

@ -32,22 +32,22 @@ namespace sgpem
KeyFile::KeyFile()
{}
KeyFile::elements_iterator
KeyFile::elements_begin() const
{
return _elements.begin();
}
KeyFile::elements_iterator
KeyFile::elements_end() const
{
return _elements.end();
}
void
KeyFile::insert_key_value(const Glib::ustring& key, const Glib::ustring& value)
{
@ -55,62 +55,62 @@ namespace sgpem
_elements.insert(val_pair);
}
const Glib::ustring*
KeyFile::search_value(const Glib::ustring& key)
{
const Glib::ustring* ret = 0;
elements_iterator cur = _elements.find(key);
if(cur != elements_end())
if (cur != elements_end())
{
ret = &((*cur).second);
}
return ret;
}
void
KeyFile::file_read(const Glib::ustring& filename)
{
std::ifstream ifs(filename.c_str());
if(ifs)
if (ifs)
{
file_read(ifs);
} // end - if(ifs)
}
void
KeyFile::file_read(std::istream& is)
KeyFile::file_read(std::istream& is)
{
if(is)
if (is)
{
_elements.clear(); // erase all elements
char buff[KEY_FILE_BUF_LEN]; //
while(is)
while (is)
{
is.getline(buff, (KEY_FILE_BUF_LEN), '\n');
// if not a comment line...
if(*buff!='\0' && *buff!='#')
if (*buff != '\0' && *buff != '#')
{
char* pos = strchr(buff, '=');
if(pos!=0)
if (pos != 0)
{
*pos = '\0';
const Glib::ustring key(buff);
const Glib::ustring value(pos+1);
const Glib::ustring value(pos + 1);
insert_key_value(key, value);
}
} // end - if not a comment line...
} // end - while(ifs))
} // end - if(ifs)
}
void
KeyFile::file_write(const Glib::ustring& filename)
{
std::ofstream ofs(filename.c_str());
if(ofs)
if (ofs)
{
file_write(ofs);
} // end - if(ofs)
@ -119,10 +119,11 @@ namespace sgpem
void
KeyFile::file_write(std::ostream& os)
{
if(os)
if (os)
{
elements_iterator iter;
for(iter = elements_begin(); iter != elements_end(); iter++){
for (iter = elements_begin(); iter != elements_end(); iter++)
{
os << (*iter).first << "=" << (*iter).second << std::endl;
}
} // end - if(ofs)

12
src/backend/key_file.hh
View file

@ -31,7 +31,7 @@
namespace sgpem
{
class KeyFile;
/** \brief Save and retrieve configuration files formatted as key=value rows.
*
* This class handles files to store and retrieve configuration preferences
@ -57,7 +57,7 @@ namespace sgpem
/** \brief Elements iterator (begin of container) initializer. */
elements_iterator elements_begin() const;
/** \brief Elements iterator (end of container) initializer */
elements_iterator elements_end() const;
@ -67,7 +67,7 @@ namespace sgpem
* \param value The value associated to the key inserted.
*/
void insert_key_value(const Glib::ustring& key, const Glib::ustring& value);
/** \brief Insert a new key/value pair.
*
* \param key The key value to insert.
@ -81,20 +81,20 @@ namespace sgpem
* \param filename The file to read from.
*/
void file_read(const Glib::ustring& filename);
/** \brief Read a stream into this object.
*
* \param is the stream to read from.
*/
void file_read(std::istream& is);
/** \brief Write into a file from this object.
*
* \param filename The file to write to.
*/
void file_write(const Glib::ustring& filename);
/** \brief Write into a stream from this object.
*
* \param os the stream to write to.

56
src/backend/module.cc
View file

@ -25,69 +25,69 @@
using namespace sgpem;
Module::Module(const Glib::ustring& identifier) throw(InvalidPluginException) :
Glib::Module(identifier),
_enabled(false),
_id(identifier),
on_init_ptr(NULL),
on_exit_ptr(NULL),
describe_ptr(NULL),
get_name_ptr(NULL),
get_author_ptr(NULL),
get_version_ptr(NULL)
{
if(!*this) throw InvalidPluginException(Module::get_last_error());
Glib::Module(identifier),
_enabled(false),
_id(identifier),
on_init_ptr(NULL),
on_exit_ptr(NULL),
describe_ptr(NULL),
get_name_ptr(NULL),
get_author_ptr(NULL),
get_version_ptr(NULL)
{
if (!*this) throw InvalidPluginException(Module::get_last_error());
// Type-safeness here is an optional, as always. :-)
std::string prefix = "sgpem__Plugin__";
if(!(get_symbol(prefix + "on_init", (void*&) on_init_ptr) &&
get_symbol(prefix + "on_exit", (void*&) on_exit_ptr) &&
get_symbol(prefix + "describe", (void*&) describe_ptr) &&
get_symbol(prefix + "get_name", (void*&) get_name_ptr) &&
get_symbol(prefix + "get_author", (void*&) get_author_ptr) &&
get_symbol(prefix + "get_version", (void*&) get_version_ptr)))
if (!(get_symbol(prefix + "on_init", (void*&) on_init_ptr) &&
get_symbol(prefix + "on_exit", (void*&) on_exit_ptr) &&
get_symbol(prefix + "describe", (void*&) describe_ptr) &&
get_symbol(prefix + "get_name", (void*&) get_name_ptr) &&
get_symbol(prefix + "get_author", (void*&) get_author_ptr) &&
get_symbol(prefix + "get_version", (void*&) get_version_ptr)))
throw InvalidPluginException("incomplete/wrong exported interface");
}
void
void
Module::set_enabled(bool enabled)
{
if(_enabled == enabled)
if (_enabled == enabled)
return;
if(enabled)
if (enabled)
on_init_ptr();
else
on_exit_ptr();
_enabled = enabled;
}
Glib::ustring
Glib::ustring
Module::get_name() const
{
return get_name_ptr();
}
Glib::ustring
Glib::ustring
Module::get_author() const
{
return get_author_ptr();
}
Glib::ustring
Glib::ustring
Module::describe() const
{
return describe_ptr();
}
float
float
Module::get_version() const
{
return get_version_ptr();
}
bool
bool
Module::get_enabled() const
{
return _enabled;

21
src/backend/module.hh
View file

@ -31,29 +31,29 @@
namespace sgpem
{
class Module;
class SG_DLLEXPORT Module : public Glib::Module
{
public:
Module(const Glib::ustring& identifier) throw(InvalidPluginException);
void set_enabled(bool enabled = true);
Glib::ustring get_name() const;
Glib::ustring get_author() const;
Glib::ustring describe() const;
float get_version() const;
bool get_enabled() const;
private:
typedef void (*f_void)(void);
typedef Glib::ustring (*f_ustring)(void);
typedef float (*f_float)(void);
bool _enabled;
Glib::ustring _id;
@ -63,8 +63,9 @@ namespace sgpem
f_ustring get_name_ptr;
f_ustring get_author_ptr;
f_float get_version_ptr;
}; //~ class Module
}
; //~ class Module
} //~ namespace sgpem

10
src/backend/plugin.hh
View file

@ -46,13 +46,13 @@ extern "C"
SG_DLLEXPORT void sgpem__Plugin__on_init();
SG_DLLEXPORT void sgpem__Plugin__on_exit();
SG_DLLEXPORT const char* sgpem__Plugin__describe();
SG_DLLEXPORT const char* sgpem__Plugin__get_name();
SG_DLLEXPORT const char* sgpem__Plugin__describe();
SG_DLLEXPORT const char* sgpem__Plugin__get_name();
SG_DLLEXPORT const char* sgpem__Plugin__get_author();
SG_DLLEXPORT float sgpem__Plugin__get_version();
SG_DLLEXPORT float sgpem__Plugin__get_version();
// To know why SG_DLLEXPORT must go *before* the return
// value, see http://gcc.gnu.org/ml/gcc-help/2005-04/msg00340.html
// To know why SG_DLLEXPORT must go *before* the return
// value, see http://gcc.gnu.org/ml/gcc-help/2005-04/msg00340.html
#ifdef __cplusplus
}

48
src/backend/plugin_manager.cc
View file

@ -38,53 +38,53 @@ using namespace std;
template class SG_DLLEXPORT Singleton<PluginManager>;
std::vector<Module*>
std::vector<Module*>
PluginManager::get_module_list() const
{
return _modules;
}
void
void
PluginManager::rescan_dirs()
{
{
Module* module = NULL;
for_each(_modules.begin(), _modules.end(),
memory::deletor<Module>());
for_each(_modules.begin(), _modules.end(),
memory::deletor<Module>());
_modules.clear();
GlobalPreferences& prefs = GlobalPreferences::get_instance();
GlobalPreferences::dir_iterator it = prefs.modules_dir_begin();
Glib::PatternSpec shared_obj(Glib::ustring("*.") + G_MODULE_SUFFIX);
while(it != prefs.modules_dir_end())
while (it != prefs.modules_dir_end())
{
Glib::Dir dir(*it);
for(Glib::DirIterator dir_it = dir.begin(); dir_it != dir.end(); ++dir_it)
for (Glib::DirIterator dir_it = dir.begin(); dir_it != dir.end(); ++dir_it)
{
// only attempt to load .so files
if(shared_obj.match(*dir_it))
if (shared_obj.match(*dir_it))
{
std::string module_path = Module::build_path(*it, *dir_it);
std::string module_path = Module::build_path(*it, *dir_it);
std::cerr << "Attempting to load module at path " << module_path << std::endl;
try
{
module = new Module(module_path);
std::cerr << "Attempting to load module at path " << module_path << std::endl;
try
{
module = new Module(module_path);
_modules.push_back(module);
std::cerr << "\tSuccess" << std::endl;
}
catch(InvalidPluginException e)
{
std::cerr << "\tFailed, invalid plugin: " << e.what() << std::endl;
}
std::cerr << "\tSuccess" << std::endl;
}
catch (InvalidPluginException e)
{
std::cerr << "\tFailed, invalid plugin: " << e.what() << std::endl;
}
}
}
it++;
}
}

7
src/backend/plugin_manager.hh
View file

@ -35,7 +35,7 @@ namespace sgpem
namespace sgpem
{
class PluginManager;
class SG_DLLEXPORT PluginManager : public Singleton<PluginManager>
{
friend class Singleton<PluginManager>;
@ -47,9 +47,10 @@ namespace sgpem
private:
PluginManager();
std::vector<Module*> _modules;
std::vector<Module*> _modules;
}; //~ class PluginManager
}
; //~ class PluginManager
} //~ namespace sgpem

4
src/backend/policy_parameters.cc
View file

@ -113,7 +113,7 @@ PolicyParameters::get_registered_string_parameters() const
/**
Tries to set the value to the parameter named "name".
\returns TRUE if the parameter named "name" has been previously registered and the value
\returns TRUE if the parameter named "name" has been previously registered and the value
stays in the range permitted by the parameter.
\returns FALSE in the other cases.
*/
@ -135,7 +135,7 @@ PolicyParameters::set_int(ustring name, const int& value)
/**
Tries to set the value to the parameter named "name".
\returns TRUE if the parameter named "name" has been previously registered and the value
\returns TRUE if the parameter named "name" has been previously registered and the value
stays in the range permitted by the parameter.
\returns FALSE in the other cases.
*/

38
src/backend/ready_queue.cc
View file

@ -27,48 +27,48 @@ using sgpem::ReadyQueue;
void
ReadyQueue::swap(position a, position b)
throw (std::out_of_range)
throw (std::out_of_range)
{
if(a == b) return;
// Usage of "at()" isn't casual:
// at() checks indexes, "[]" doesn't.
// Once we've done the check once, we
// can assume it's safe to use "[]";
// this for performance reasons.
Thread* temp = _scheds.at(a);
_scheds[a] = _scheds.at(b);
_scheds[b] = temp;
if (a == b) return;
// Usage of "at()" isn't casual:
// at() checks indexes, "[]" doesn't.
// Once we've done the check once, we
// can assume it's safe to use "[]";
// this for performance reasons.
Thread* temp = _scheds.at(a);
_scheds[a] = _scheds.at(b);
_scheds[b] = temp;
}
ReadyQueue::size_t
ReadyQueue::size() const
{
return _scheds.size();
return _scheds.size();
}
sgpem::Thread&
ReadyQueue::get_item_at(position index)
throw (std::out_of_range)
throw (std::out_of_range)
{
// Checks index access
return *_scheds.at(index);
// Checks index access
return *_scheds.at(index);
}
const sgpem::Thread&
ReadyQueue::get_item_at(position index) const
throw (std::out_of_range)
throw (std::out_of_range)
{
// Checks index access
return *_scheds.at(index);
// Checks index access
return *_scheds.at(index);
}
void
ReadyQueue::append(Thread& thread)
{
_scheds.push_back(&thread);
_scheds.push_back(&thread);
}
void

24
src/backend/ready_queue.hh
View file

@ -28,25 +28,25 @@
namespace sgpem
{
class ReadyQueue;
class Thread;
class ReadyQueue;
class Thread;
class SG_DLLEXPORT ReadyQueue
{
public:
typedef unsigned int position;
typedef unsigned int size_t;
typedef unsigned int position;
typedef unsigned int size_t;
void swap(position a, position b) throw (std::out_of_range);
size_t size() const;
Thread& get_item_at(position index) throw (std::out_of_range);
const Thread& get_item_at(position index) const throw (std::out_of_range);
void append(Thread& schedulable);
void swap(position a, position b) throw (std::out_of_range);
size_t size() const;
Thread& get_item_at(position index) throw (std::out_of_range);
const Thread& get_item_at(position index) const throw (std::out_of_range);
void append(Thread& schedulable);
void erase_first();
private:
typedef std::vector<Thread*> Threads;
Threads _scheds;
typedef std::vector<Thread*> Threads;
Threads _scheds;
};
}

6
src/backend/request.hh
View file

@ -40,13 +40,13 @@ namespace sgpem
state_allocated = 1 << 1,
state_future = 1 << 2,
state_exhausted = 1 << 3,
state_allocable = 1 << 4
state_allocable = 1 << 4
};
virtual ~Request();
virtual Thread& get_thread() = 0;
virtual bool operator==(const Request& op2) const = 0;
virtual std::vector<SubRequest*> get_subrequests() = 0;

2
src/backend/resource.hh
View file

@ -34,7 +34,7 @@ namespace sgpem
public:
virtual ~Resource();
virtual bool operator==(const Resource& op2) const = 0;
virtual bool operator==(const Resource& op2) const = 0;
virtual Glib::ustring get_name() const = 0;
virtual unsigned int get_places() const = 0;

24
src/backend/resource_policies_gatekeeper.cc
View file

@ -55,7 +55,7 @@ ResourcePoliciesGatekeeper::register_manager(ResourcePolicyManager* manager)
ManagerIterator end = _registered.end();
if(find(_registered.begin(), end, manager) == end)
if (find(_registered.begin(), end, manager) == end)
_registered.push_back(manager);
}
@ -67,7 +67,7 @@ ResourcePoliciesGatekeeper::unregister_manager(ResourcePolicyManager* manager)
ManagerIterator end = _registered.end();
ManagerIterator pos = find(_registered.begin(), end, manager);
if(pos != end)
if (pos != end)
{
deactivate_policies(**pos);
_registered.erase(pos);
@ -81,7 +81,7 @@ ResourcePoliciesGatekeeper::get_current_policy(History* history) throw(runtime_e
PolicyIterator policy = _active_policies.find(history);
if(policy == _active_policies.end())
if (policy == _active_policies.end())
throw runtime_error("No active policy associated with this "
"history is available.");
@ -97,8 +97,7 @@ ResourcePoliciesGatekeeper::activate_policy(History *history, ResourcePolicy* po
}
ResourcePoliciesGatekeeper::ResourcePoliciesGatekeeper()
{
}
{}
void
ResourcePoliciesGatekeeper::deactivate_policies(const ResourcePolicyManager& manager)
@ -107,18 +106,19 @@ ResourcePoliciesGatekeeper::deactivate_policies(const ResourcePolicyManager& man
const vector<ResourcePolicy*>& policies = manager.get_avail_policies();
for(AvailableIt avail_it = policies.begin(); avail_it != policies.end(); ++avail_it)
for (AvailableIt avail_it = policies.begin(); avail_it != policies.end(); ++avail_it)
{
// TODO isn't there a way to write more compact code by using
// library utilities?
for(PolicyIterator it = _active_policies.begin(); it != _active_policies.end();)
for (PolicyIterator it = _active_policies.begin(); it != _active_policies.end();)
{
// FIXME Is this necessary? It just came across my mind the idea that
// FIXME Is this necessary? It just came across my mind the idea that
// incrementing an invalid iterator might be unsafe...
PolicyIterator next = it; ++next;
if(it->second == *avail_it)
_active_policies.erase(it);
PolicyIterator next = it;
++next;
if (it->second == *avail_it)
_active_policies.erase(it);
it = next;
}

12
src/backend/resource_policies_gatekeeper.hh
View file

@ -51,26 +51,26 @@ namespace sgpem
public:
typedef std::vector<ResourcePolicyManager*> Managers;
const Managers& get_registered() const;
void register_manager(ResourcePolicyManager* manager);
void register_manager(ResourcePolicyManager* manager);
void unregister_manager(ResourcePolicyManager* manager);
void unregister_manager(ResourcePolicyManager* manager);
ResourcePolicy& get_current_policy(History* history) throw(std::runtime_error);
void activate_policy(History* history, ResourcePolicy* policy);
void activate_policy(History* history, ResourcePolicy* policy);
private:
ResourcePoliciesGatekeeper(); //private constructor.
ResourcePoliciesGatekeeper(const ResourcePoliciesGatekeeper&);
ResourcePoliciesGatekeeper& operator=(const ResourcePoliciesGatekeeper&);
void deactivate_policies(const ResourcePolicyManager& manager);
std::vector<ResourcePolicyManager*> _registered;
std::map<History*, ResourcePolicy*> _active_policies;
std::map<History*, ResourcePolicy*> _active_policies;
};
}//~ namespace sgpem

4
src/backend/resource_policy.hh
View file

@ -56,8 +56,8 @@ namespace sgpem
Because it's a pure virtual method, must be re-implemented
in concrete derived classes.
*/
virtual void enforce() throw(UserInterruptException) = 0;
virtual void enforce() throw(UserInterruptException) = 0;
/**
Gets a string description of the policy.

2
src/backend/schedulable.hh
View file

@ -51,7 +51,7 @@ namespace sgpem
virtual ~Schedulable() = 0;
virtual bool operator==(const Schedulable& op2) const = 0;
virtual bool operator==(const Schedulable& op2) const = 0;
virtual Glib::ustring get_name() const = 0;

899
src/backend/scheduler.cc
View file

File diff suppressed because it is too large Load diff

18
src/backend/scheduler.hh
View file

@ -41,7 +41,7 @@ namespace sgpem
namespace sgpem
{
class Scheduler;
/** \brief Manages the DynamicSchedulable objects, implementing a given policy.
@ -69,13 +69,13 @@ namespace sgpem
Resets the simulation to the initial state.
*/
void reset_status();
/**
Generates a new ReadyQueue representing the status of the processes
at the simulation instant next to the current one, and extends the History by
one instant with it.
/**
Generates a new ReadyQueue representing the status of the processes
at the simulation instant next to the current one, and extends the History by
one instant with it.
\return false If the simulation has ended, true otherwise
*/
\return false If the simulation has ended, true otherwise
*/
bool step_forward(History& history, CPUPolicy& cpu_policy) throw(UserInterruptException);
/**
@ -84,9 +84,9 @@ namespace sgpem
*/
CPUPolicy* get_policy();
private:
private:
Scheduler(); //private constructor.
ReadyQueue* _ready_queue;
CPUPolicy* _policy;

10
src/backend/serialize_visitor.hh
View file

@ -68,29 +68,29 @@ namespace sgpem
BUG: a resource must be saved with her own associated key.
*/
virtual void from_resource(const Resource& obj) throw(SerializerError) = 0;
/**
\brief Add output to the serializer taking data from resource and key
BUG FIXED: This save a resource with her own associated key.
*/
virtual void from_resource(const Resource& obj, const Glib::ustring& key) throw(SerializerError) = 0;
/**
\brief Add output to the serializer taking data from process
*/
virtual void from_process(const Process& obj) throw(SerializerError) = 0;
/**
\brief Add output to the serializer taking data from thread
*/
virtual void from_thread(const Thread& obj) throw(SerializerError) = 0;
/**
\brief Add output to the serializer taking data from request
*/
virtual void from_request(const Request& obj) throw(SerializerError) = 0;
/**
\brief Add output to the serializer taking data from subrequest
*/

2
src/backend/serializer.cc
View file

@ -27,7 +27,7 @@ using namespace sgpem;
Serializer::Serializer()
{
SerializersGatekeeper::get_instance().register_serializer(this);
}
}
Serializer::~Serializer()
{}

2
src/backend/serializer.hh
View file

@ -34,7 +34,7 @@ namespace sgpem
class SG_DLLEXPORT Serializer
{
public:
Serializer();
Serializer();
virtual ~Serializer() = 0;
virtual void save_snapshot(const Glib::ustring& filename, const History& hist) throw(SerializerError) = 0;

5
src/backend/serializer_error.cc
View file

@ -25,6 +25,5 @@
using namespace sgpem;
SerializerError::SerializerError(const std::string& what) :
std::runtime_error(what)
{
}
std::runtime_error(what)
{}

3
src/backend/serializer_error.hh
View file

@ -31,7 +31,8 @@ namespace sgpem
{
public:
SerializerError(const std::string& what);
}; //~ class SerializerError
}
; //~ class SerializerError
} //~ namespace sgpem

4
src/backend/serializers_gatekeeper.cc
View file

@ -52,7 +52,7 @@ SerializersGatekeeper::register_serializer(Serializer* serializer)
SerializerIterator end = _registered.end();
if(find(_registered.begin(), end, serializer) == end)
if (find(_registered.begin(), end, serializer) == end)
_registered.push_back(serializer);
}
@ -64,7 +64,7 @@ SerializersGatekeeper::unregister_serializer(Serializer* serializer)
SerializerIterator end = _registered.end();
SerializerIterator pos = find(_registered.begin(), end, serializer);
if(pos != end)
if (pos != end)
{
_registered.erase(pos);
}

3
src/backend/simulation.cc
View file

@ -30,8 +30,7 @@ template class SG_DLLEXPORT Singleton<ConcreteSimulation>;
Simulation::~Simulation()
{
}
{}
Simulation&
Simulation::get_instance()

10
src/backend/simulation.hh
View file

@ -68,9 +68,9 @@ namespace sgpem
state_paused,
state_stopped
};
virtual ~Simulation();
/**
\brief Runs the simulation.
@ -109,7 +109,7 @@ namespace sgpem
\see set_timer()
*/
virtual int get_timer() const = 0;
/**
\brief This methods allows to change the way the simulation progresses.
@ -128,7 +128,7 @@ namespace sgpem
virtual bool get_mode() const = 0;
virtual state get_state() const = 0;
/**
\brief Setup the policy to be used by the system.
*/
@ -140,7 +140,7 @@ namespace sgpem
virtual CPUPolicy* get_policy() = 0;
virtual History& get_history() = 0;
/**
* Small kludge to avoid the need for declaration of ConcreteSimulation
* by the calling code of Simulation::get_instance()

18
src/backend/static_process.cc
View file

@ -23,7 +23,7 @@ using namespace sgpem;
StaticProcess::StaticProcess(const Glib::ustring& name, const unsigned int& arrival, const int& priority)
: StaticSchedulable(name, priority), _start_time(arrival)
: StaticSchedulable(name, priority), _start_time(arrival)
{}
@ -34,24 +34,24 @@ StaticProcess::~StaticProcess()
unsigned int
StaticProcess::get_arrival_time() const
{
return _start_time;
return _start_time;
}
unsigned int
StaticProcess::get_total_cpu_time() const
{
typedef std::vector<StaticThread*>::const_iterator ThreadIterator;
typedef std::vector<StaticThread*>::const_iterator ThreadIterator;
unsigned int result = 0;
for(ThreadIterator it = _threads.begin(); it != _threads.end(); it++)
result += (*it)->get_total_cpu_time();
return result;
unsigned int result = 0;
for (ThreadIterator it = _threads.begin(); it != _threads.end(); it++)
result += (*it)->get_total_cpu_time();
return result;
}
std::vector<StaticThread*>&
std::vector<StaticThread*>&
StaticProcess::get_threads()
{
return _threads;
return _threads;
}

16
src/backend/static_process.hh
View file

@ -47,17 +47,17 @@ namespace sgpem
/** \brief Destructor. */
virtual ~StaticProcess();
virtual unsigned int get_total_cpu_time() const;
virtual unsigned int get_arrival_time() const;
virtual unsigned int get_total_cpu_time() const;
virtual unsigned int get_arrival_time() const;
// Does the job also of add_thread() and remove_thread(). :-)
// Since we're touching backend internals, we can do this safely
// (because we know what we're doing, isn't it?)
virtual std::vector<StaticThread*>& get_threads();
// Does the job also of add_thread() and remove_thread(). :-)
// Since we're touching backend internals, we can do this safely
// (because we know what we're doing, isn't it?)
virtual std::vector<StaticThread*>& get_threads();
private:
unsigned int _start_time;
std::vector<StaticThread*> _threads;
unsigned int _start_time;
std::vector<StaticThread*> _threads;
};
}

8
src/backend/static_request.cc
View file

@ -31,14 +31,14 @@ StaticRequest::StaticRequest(StaticThread* thread,
_thread(thread), _instant(instant)
{
assert(thread != NULL);
_thread->get_requests().push_back(this);
_thread->get_requests().push_back(this);
}
StaticRequest::~StaticRequest()
{
typedef std::vector<StaticRequest*> Requests;
Requests& siblings = _thread->get_requests();
siblings.erase(find(siblings.begin(), siblings.end(), this));
typedef std::vector<StaticRequest*> Requests;
Requests& siblings = _thread->get_requests();
siblings.erase(find(siblings.begin(), siblings.end(), this));
}
unsigned int

2
src/backend/static_schedulable.hh
View file

@ -68,7 +68,7 @@ namespace sgpem
* user, that allows it to be quickly recognized.
*/
virtual const Glib::ustring& get_name() const;
private:
Glib::ustring _name;
int _priority;

2
src/backend/static_sub_request.cc
View file

@ -38,7 +38,7 @@ StaticSubRequest::StaticSubRequest(resource_key_t resource_key,
}
StaticSubRequest::~StaticSubRequest()
StaticSubRequest::~StaticSubRequest()
{
// See comment in constructor.

16
src/backend/static_thread.cc
View file

@ -29,23 +29,23 @@ using namespace std;
StaticThread::StaticThread(const Glib::ustring& name,
StaticProcess& process,
unsigned int cpu_time,
unsigned int cpu_time,
unsigned int arrival_time,
int base_priority) :
StaticSchedulable(name, base_priority),
_start_time_delta(arrival_time),
_required_cpu_time(cpu_time),
_start_time_delta(arrival_time),
_required_cpu_time(cpu_time),
_process(&process)
{
process.get_threads().push_back(this);
process.get_threads().push_back(this);
}
StaticThread::~StaticThread()
{
typedef std::vector<StaticThread*> Threads;
Threads& siblings = _process->get_threads();
siblings.erase(find(siblings.begin(), siblings.end(), this));
typedef std::vector<StaticThread*> Threads;
Threads& siblings = _process->get_threads();
siblings.erase(find(siblings.begin(), siblings.end(), this));
}
@ -70,5 +70,5 @@ StaticThread::get_process()
std::vector<StaticRequest*>&
StaticThread::get_requests()
{
return _static_requests;
return _static_requests;
}

14
src/backend/static_thread.hh
View file

@ -42,11 +42,11 @@ namespace sgpem
public:
StaticThread(const Glib::ustring& name,
StaticProcess& process,
unsigned int cpu_time,
unsigned int cpu_time,
unsigned int arrival_time = 0,
int base_priority = 0);
virtual ~StaticThread();
virtual ~StaticThread();
virtual unsigned int get_total_cpu_time() const;
@ -54,11 +54,11 @@ namespace sgpem
virtual StaticProcess& get_process();
// Caller can use directly the vector instead that
// the "remove_request()" and "add_request()" method
// of the design. Since this class is internal to the
// backend anyway, this is okay.
virtual std::vector<StaticRequest*>& get_requests();
// Caller can use directly the vector instead that
// the "remove_request()" and "add_request()" method
// of the design. Since this class is internal to the
// backend anyway, this is okay.
virtual std::vector<StaticRequest*>& get_requests();
private:
StaticThread(const StaticThread&);

374
src/backend/string_utils.cc
View file

@ -29,210 +29,210 @@ using Glib::ustring;
namespace sgpem
{
/* Force template instantiation to allow visibility outside this DSO */
template SG_DLLEXPORT int string_to<int>(const Glib::ustring&);
template SG_DLLEXPORT float string_to<float>(const Glib::ustring&);
/* Force template instantiation to allow visibility outside this DSO */
template SG_DLLEXPORT int string_to<int>(const Glib::ustring&);
template SG_DLLEXPORT float string_to<float>(const Glib::ustring&);
// Specialized further down in this file:
// template SG_DLLEXPORT bool string_to<bool>(const Glib::ustring&);
// Specialized further down in this file:
// template SG_DLLEXPORT bool string_to<bool>(const Glib::ustring&);
/**
\brief A function that converts a Unicode string to an integer value
The string can contain ONLY digits and the "minus" character.
\returns TRUE if the string is well formatted
\returns FALSE otherwise
*/
bool
string_to_int(const ustring& str, int& num)
{
static const ustring allvalid = "0123456789-";
static const ustring digits = "0123456789";
/**
\brief A function that converts a Unicode string to an integer value
// the string can't be empty
if (str.length() == 0 || (str.length() == 1 && str[0] == '-'))
return false;
The string can contain ONLY digits and the "minus" character.
//checks if the string contains only digits
if (str.find_first_not_of(allvalid) < str.length())
return false;
if (str.substr(1).find_first_not_of(digits) < str.length() - 1)
return false;
num = 0;
int multiplier = 1, val;
int start; //the position of the biggest digit
if (str[0] == '-')
start = 1;
else
start = 0;
for (int pos = str.length() - 1; pos >= start ; pos--)
\returns TRUE if the string is well formatted
\returns FALSE otherwise
*/
bool
string_to_int(const ustring& str, int& num)
{
val = str[pos] - 48; //the INTEGER value of the digit
num += val * multiplier;
multiplier *= 10;
}
//if there is the minus then multiply for -1
if (start == 1)
num *= -1;
return true;
}
static const ustring allvalid = "0123456789-";
static const ustring digits = "0123456789";
template <typename T>
T
string_to(const ustring& str) throw(domain_error)
{
if(tokenize(str).size() != 1)
throw domain_error(_("too few or too many tokens"));
// the string can't be empty
if (str.length() == 0 || (str.length() == 1 && str[0] == '-'))
return false;
istringstream iss(str);
//checks if the string contains only digits
if (str.find_first_not_of(allvalid) < str.length())
return false;
if (str.substr(1).find_first_not_of(digits) < str.length() - 1)
return false;
iss.exceptions(ios_base::failbit | ios_base::badbit);
T value;
try
{
iss >> value;
}
catch(ios_base::failure e)
{
throw domain_error(e.what());
}
// disable exceptions, otherwise peek() will throw them!
// how useless!!!
iss.exceptions(ios_base::goodbit);
if(iss.peek() != istringstream::traits_type::eof())
throw domain_error(_("incorrect number format"));
return value;
}
template <>
SG_DLLEXPORT bool
string_to<bool>(const Glib::ustring& str) throw(domain_error)
{
if(tokenize(str).size() != 1)
throw domain_error(_("too few or too many tokens"));
istringstream iss(str);
iss.exceptions(ios_base::failbit | ios_base::badbit);
bool value;
try
{
iss >> boolalpha >> value;
}
catch(ios_base::failure e)
{
throw domain_error(e.what());
}
// disable exceptions, otherwise peek() will throw them!
// how useless!!!
iss.exceptions(ios_base::goodbit);
if(iss.peek() != istringstream::traits_type::eof())
throw domain_error(_("incorrect boolean"));
return value;
}
/**
\brief A function that converts an integer value to an Unicode string
*/
void
int_to_string(const int& num, ustring& str)
{
if (num == 0)
{
str = '0';
return;
}
str = "";
int val = num;
bool negative = (val < 0) ? true : false;
if (negative) val *= -1;
while (true)
{
str = char(val % 10 + 48) + str;
if (val > 1 && val / 10 != 0)
val /= 10;
num = 0;
int multiplier = 1, val;
int start; //the position of the biggest digit
if (str[0] == '-')
start = 1;
else
break;
start = 0;
for (int pos = str.length() - 1; pos >= start ; pos--)
{
val = str[pos] - 48; //the INTEGER value of the digit
num += val * multiplier;
multiplier *= 10;
}
//if there is the minus then multiply for -1
if (start == 1)
num *= -1;
return true;
}
if (negative)
str = '-' + str;
}
void
float_to_string(const float& f, Glib::ustring& str)
{
stringstream ss;
ss << f;
char p[20];
ss.getline(p, 20);
str = p;
}
template <typename T>
T
string_to(const ustring& str) throw(domain_error)
{
if (tokenize(str).size() != 1)
throw domain_error(_("too few or too many tokens"));
void
string_to_float(const Glib::ustring& str, float& f)
{
stringstream ss;
ss << str;
ss >> f;
}
istringstream iss(str);
iss.exceptions(ios_base::failbit | ios_base::badbit);
T value;
try
{
iss >> value;
}
catch (ios_base::failure e)
{
throw domain_error(e.what());
}
// disable exceptions, otherwise peek() will throw them!
// how useless!!!
iss.exceptions(ios_base::goodbit);
if (iss.peek() != istringstream::traits_type::eof())
throw domain_error(_("incorrect number format"));
return value;
}
template <>
SG_DLLEXPORT bool
string_to<bool>(const Glib::ustring& str) throw(domain_error)
{
if (tokenize(str).size() != 1)
throw domain_error(_("too few or too many tokens"));
istringstream iss(str);
iss.exceptions(ios_base::failbit | ios_base::badbit);
bool value;
try
{
iss >> boolalpha >> value;
}
catch (ios_base::failure e)
{
throw domain_error(e.what());
}
// disable exceptions, otherwise peek() will throw them!
// how useless!!!
iss.exceptions(ios_base::goodbit);
if (iss.peek() != istringstream::traits_type::eof())
throw domain_error(_("incorrect boolean"));
return value;
}
/**
\brief A function that converts an integer value to an Unicode string
*/
void
int_to_string(const int& num, ustring& str)
{
if (num == 0)
{
str = '0';
return;
}
str = "";
int val = num;
bool negative = (val < 0) ? true : false;
if (negative) val *= -1;
while (true)
{
str = char(val % 10 + 48) + str;
if (val > 1 && val / 10 != 0)
val /= 10;
else
break;
}
if (negative)
str = '-' + str;
}
void
float_to_string(const float& f, Glib::ustring& str)
{
stringstream ss;
ss << f;
char p[20];
ss.getline(p, 20);
str = p;
}
void
string_to_float(const Glib::ustring& str, float& f)
{
stringstream ss;
ss << str;
ss >> f;
}
// helper function for tokenize()
static void
add_token(Tokens& tokens, const ustring& token)
{
if(token.size() > 0)
tokens.push_back(token);
}
Tokens
tokenize(const ustring& str)
{
istringstream iss(str);
Tokens tokens;
while(iss)
static void
add_token(Tokens& tokens, const ustring& token)
{
ustring token;
iss >> token;
ustring::size_type index;
// for the SET command, parse the assigment symbol as
// a separate token
do
{
index = token.find('=');
if(index != ustring::npos)
{
add_token(tokens, token.substr(0, index));
add_token(tokens, "=");
// the second argument can safely be out of range
token = token.substr(index + 1, token.size());
}
}
while(index != ustring::npos);
add_token(tokens, token);
if (token.size() > 0)
tokens.push_back(token);
}
return tokens;
}
Tokens
tokenize(const ustring& str)
{
istringstream iss(str);
Tokens tokens;
while (iss)
{
ustring token;
iss >> token;
ustring::size_type index;
// for the SET command, parse the assigment symbol as
// a separate token
do
{
index = token.find('=');
if (index != ustring::npos)
{
add_token(tokens, token.substr(0, index));
add_token(tokens, "=");
// the second argument can safely be out of range
token = token.substr(index + 1, token.size());
}
}
while (index != ustring::npos);
add_token(tokens, token);
}
return tokens;
}
}

2
src/backend/string_utils.hh
View file

@ -31,7 +31,7 @@
namespace sgpem
{
typedef std::vector<Glib::ustring> Tokens;
/**\brief This function tries to convert a string into an integer value.
The string can contain only digits and the minus character (for negative numbers).

14
src/backend/sub_request.hh
View file

@ -34,24 +34,24 @@ namespace sgpem
class SG_DLLEXPORT SubRequest
{
public:
typedef int resource_key_t;
typedef Request::state state;
typedef int resource_key_t;
typedef Request::state state;
virtual ~SubRequest();
virtual bool operator==(const SubRequest& op2) const = 0;
virtual bool operator==(const SubRequest& op2) const = 0;
virtual resource_key_t get_resource_key() const = 0;
virtual unsigned int get_length() const = 0;
virtual unsigned int get_length() const = 0;
virtual int get_queue_position() const = 0;
virtual state get_state() const = 0;
virtual state get_state() const = 0;
virtual unsigned int get_remaining_time() const = 0;
virtual unsigned int get_remaining_time() const = 0;
virtual Request& get_request() = 0;
virtual Request& get_request() = 0;
virtual void serialize(SerializeVisitor& translator) const = 0;
};

2
src/backend/thread.hh
View file

@ -38,7 +38,7 @@ namespace sgpem
public:
virtual ~Thread();
virtual Process& get_process() = 0;
virtual Process& get_process() = 0;
virtual std::vector<Request*> get_requests() = 0;
virtual void serialize(SerializeVisitor& translator) const = 0;
};

83
src/cairo_elements.cc
View file

@ -26,12 +26,11 @@ using namespace sgpem;
CairoElements::CairoElements(cairo_t* const ctx)
: _ctx(ctx)
{
}
: _ctx(ctx)
{}
void
void
CairoElements::draw_3dsphere(const Point& center, float radius, const Color& cl)
{
cairo_t*& cr = _ctx;
@ -40,7 +39,7 @@ CairoElements::draw_3dsphere(const Point& center, float radius, const Color& cl)
const float& r = cl.r;
const float& g = cl.g;
const float& b = cl.b;
// Draw initial sphere perimeter
cairo_save(cr);
cairo_new_path(cr);
@ -55,35 +54,35 @@ CairoElements::draw_3dsphere(const Point& center, float radius, const Color& cl)
cairo_set_line_width(cr, radius * .01);
cairo_stroke(cr);
cairo_restore(cr);
// Internal gradient
cairo_save(cr);
grad = cairo_pattern_create_linear(x, y, x, y + radius);
cairo_pattern_add_color_stop_rgba(grad, 1, r - .4, g - .4, b - .4, 1);
cairo_pattern_add_color_stop_rgba(grad, 0, r, g, b, .7);
cairo_set_source(cr, grad);
cairo_translate(cr, x*.2, (y + radius*8/9) * 1/3);
cairo_scale(cr, .8, 2./3);
cairo_translate(cr, x*.2, (y + radius*8 / 9) * 1 / 3);
cairo_scale(cr, .8, 2. / 3);
cairo_arc(cr, x, y, radius, 0, 2*M_PI);
cairo_fill(cr);
cairo_pattern_destroy(grad);
cairo_restore(cr);
// Internal glow
cairo_save(cr);
grad = cairo_pattern_create_linear(x, y - radius, x, y);
cairo_pattern_add_color_stop_rgba(grad, 0, 1, 1, 1, .9);
cairo_pattern_add_color_stop_rgba(grad, 1, 1, 1, 1, .2);
cairo_set_source(cr, grad);
cairo_translate(cr, x * .2, (y - radius*8/9) * 1/3);
cairo_scale(cr, .8, 2./3);
cairo_translate(cr, x * .2, (y - radius*8 / 9) * 1 / 3);
cairo_scale(cr, .8, 2. / 3);
cairo_arc(cr, x, y, radius, 0, 2*M_PI);
cairo_fill(cr);
cairo_pattern_destroy(grad);
cairo_restore(cr);
cairo_restore(cr);
}
void
void
CairoElements::draw_3dcube(const Rectangle& area, const Color& cl)
{
cairo_t*& cr = _ctx;
@ -97,7 +96,7 @@ CairoElements::draw_3dcube(const Rectangle& area, const Color& cl)
}
void
void
CairoElements::draw_container(const Rectangle& area)
{
cairo_t*& cr = _ctx;
@ -105,27 +104,27 @@ CairoElements::draw_container(const Rectangle& area)
const float& y0 = area.y0;
const float& w = area.w;
const float& h = area.h;
const double corner_radius = 0.05;
cairo_save(cr);
cairo_new_path(cr);
cairo_move_to(cr, x0 + corner_radius, y0);
// NW -> NE
cairo_line_to(cr, x0+w - corner_radius, y0);
cairo_curve_to(cr, x0+w, y0, x0+w, y0, x0+w, y0 + corner_radius);
cairo_line_to(cr, x0 + w - corner_radius, y0);
cairo_curve_to(cr, x0 + w, y0, x0 + w, y0, x0 + w, y0 + corner_radius);
// NE -> SE
cairo_line_to(cr, x0+w, y0+h - corner_radius);
cairo_curve_to(cr, x0+w, y0+h, x0+w, y0+h, x0+w - corner_radius, y0+h);
cairo_line_to(cr, x0 + w, y0 + h - corner_radius);
cairo_curve_to(cr, x0 + w, y0 + h, x0 + w, y0 + h, x0 + w - corner_radius, y0 + h);
// SE -> SW
cairo_line_to(cr, x0 + corner_radius, y0+h);
cairo_curve_to(cr, x0, y0+h, x0, y0+h, x0, y0+h - corner_radius);
cairo_line_to(cr, x0 + corner_radius, y0 + h);
cairo_curve_to(cr, x0, y0 + h, x0, y0 + h, x0, y0 + h - corner_radius);
// SW -> NW
cairo_line_to(cr, x0, y0 + corner_radius);
cairo_curve_to(cr, x0, y0, x0, y0, x0 + corner_radius, y0);
cairo_close_path(cr);
cairo_set_source_rgb(cr, 1, 1, 0.9);
cairo_fill_preserve(cr);
@ -137,7 +136,7 @@ CairoElements::draw_container(const Rectangle& area)
}
void
void
CairoElements::draw_expandable(const Rectangle& area, bool expanded)
{
cairo_t*& cr = _ctx;
@ -145,42 +144,40 @@ CairoElements::draw_expandable(const Rectangle& area, bool expanded)
const float& y0 = area.y0;
const float& w = area.w;
const float& h = area.h;
cairo_save(cr);
cairo_set_line_width(cr, .005);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_new_path(cr);
cairo_rectangle(cr, x0, y0, w, h);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_stroke(cr);
cairo_move_to(cr, x0 + w/10, y0 + h/2);
cairo_line_to(cr, x0 + w*9/10, y0 + h/2);
cairo_move_to(cr, x0 + w / 10, y0 + h / 2);
cairo_line_to(cr, x0 + w*9 / 10, y0 + h / 2);
cairo_stroke(cr);
if(!expanded)
{
cairo_move_to(cr, x0 + w/2, y0 + h/10);
cairo_line_to(cr, x0 + w/2, y0 + h*9/10);
cairo_stroke(cr);
}
if (!expanded)
{
cairo_move_to(cr, x0 + w / 2, y0 + h / 10);
cairo_line_to(cr, x0 + w / 2, y0 + h*9 / 10);
cairo_stroke(cr);
}
cairo_restore(cr);
}
Rectangle draw_thread_status(const Point& top_left_crn,
Rectangle draw_thread_status(const Point& top_left_crn,
const Thread& thread_info)
{
}
{}
Rectangle draw_process_status(const Point& top_left_crn,
const Process& process_info)
{
}
{}

4
src/cairo_elements.hh
View file

@ -57,13 +57,13 @@ namespace sgpem
{
public:
CairoElements(cairo_t* const ctx);
void draw_3dsphere(const Point& center, float radius, const Color& cl);
void draw_3dcube(const Rectangle& area, const Color& cl);
void draw_container(const Rectangle& area);
void draw_expandable(const Rectangle& area, bool expanded = false);
Rectangle draw_thread_status(const Point& top_left_crn,
Rectangle draw_thread_status(const Point& top_left_crn,
const Thread& thread_info);
Rectangle draw_process_status(const Point& top_left_crn,
const Process& process_info);

82
src/cairo_widget.cc
View file

@ -34,14 +34,14 @@ using namespace sgpem;
CairoWidget::CairoWidget()
: Glib::ObjectBase("sgpem_CairoWidget"),
Gtk::Widget(), _h(1), _buf(NULL)
: Glib::ObjectBase("sgpem_CairoWidget"),
Gtk::Widget(), _h(1), _buf(NULL)
{
set_flags(Gtk::NO_WINDOW);
// Register this observer:
Simulation::get_instance().get_history().attach(*this);
}
CairoWidget::~CairoWidget()
{
@ -49,12 +49,12 @@ CairoWidget::~CairoWidget()
}
void
void
CairoWidget::update(const History& history)
{
// get_window() returns a null pointer
// if the widget has not been realized
if(!is_realized())
if (!is_realized())
return; // Nowhere to draw to.
// Determine the final height before to start drawing
@ -66,11 +66,11 @@ CairoWidget::update(const History& history)
// Draw the widget background as the first thing.
// I've seen this is how it's done in the very Gtk+ toolkit
// for the GtkProgressBar widget.
GtkStyle* gStyle = get_style()->gobj();
gtk_paint_box(gStyle, _buf->gobj(),
GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
GtkStyle* gStyle = get_style()->gobj();
gtk_paint_box(gStyle, _buf->gobj(),
GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
NULL, this->gobj(), "through",
0, 0, w, _h);
0, 0, w, _h);
cairo_t* ctx = gdk_cairo_create(_buf->gobj());
@ -86,10 +86,10 @@ CairoWidget::update(const History& history)
}
void
void
CairoWidget::on_realize()
{
if(is_realized()) return;
if (is_realized()) return;
Gtk::Widget::on_realize();
ensure_style();
@ -97,32 +97,32 @@ CairoWidget::on_realize()
GdkWindowAttr attributes;
memset(&attributes, 0, sizeof(attributes));
Gtk::Allocation alloc = get_allocation();
Gtk::Allocation alloc = get_allocation();
attributes.x = alloc.get_x();
attributes.y = alloc.get_y();
attributes.width = alloc.get_width();
attributes.height = alloc.get_height();
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.x = alloc.get_x();
attributes.y = alloc.get_y();
attributes.width = alloc.get_width();
attributes.height = alloc.get_height();
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.event_mask = get_events() | GDK_EXPOSURE_MASK;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.visual = get_visual()->gobj();
attributes.colormap = get_colormap()->gobj();
static const gint attributes_mask = Gdk::WA_X | Gdk::WA_Y | Gdk::WA_WMCLASS
| Gdk::WA_VISUAL | Gdk::WA_COLORMAP;
static const gint attributes_mask = Gdk::WA_X | Gdk::WA_Y | Gdk::WA_WMCLASS
| Gdk::WA_VISUAL | Gdk::WA_COLORMAP;
Glib::RefPtr<Gdk::Window> window = Gdk::Window::create(get_parent_window(),
&attributes,
attributes_mask);
Glib::RefPtr<Gdk::Window> window = Gdk::Window::create(get_parent_window(),
&attributes,
attributes_mask);
unset_flags(Gtk::NO_WINDOW);
set_window(window);
window->set_user_data(gobj());
set_window(window);
window->set_user_data(gobj());
// Not sure if the following line is needed:
gtk_style_attach(get_style()->gobj(), window->gobj());
get_style()->set_background(window, Gtk::STATE_ACTIVE);
get_style()->set_background(window, Gtk::STATE_ACTIVE);
}
void
@ -130,46 +130,46 @@ CairoWidget::on_size_request(Gtk::Requisition* requisition)
{
// FIXME: take correct measures, consider also using a viewport(?)
*requisition = Gtk::Requisition();
requisition->width = get_allocation().get_width();
requisition->height = _h;
requisition->width = get_allocation().get_width();
requisition->height = _h;
}
void
CairoWidget::on_size_allocate(const Gtk::Allocation& allocation)
{
set_allocation(allocation);
if(is_realized())
get_window()->move_resize(allocation.get_x(), allocation.get_y(),
allocation.get_width(), allocation.get_height());
set_allocation(allocation);
if (is_realized())
get_window()->move_resize(allocation.get_x(), allocation.get_y(),
allocation.get_width(), allocation.get_height());
}
bool
bool
CairoWidget::on_expose_event(GdkEventExpose* event)
{
if(event == NULL || event->count > 0)
if (event == NULL || event->count > 0)
return false;
// calculated dinamically:
int w = get_allocation().get_width();
set_size_request(w, _h);
// Clip to redraw only the smallest possible area
// Use double buffering or we're CPU-dead
// Copy from the buffer to the screen
if(_buf)
get_window()->draw_drawable(get_style()->get_black_gc(), _buf,
event->area.x, event->area.y,
if (_buf)
get_window()->draw_drawable(get_style()->get_black_gc(), _buf,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
return true;
}
bool
bool
CairoWidget::on_button_press_event(GdkEventButton* event)
{
// Not here. Yet.

6
src/cairo_widget.hh
View file

@ -40,8 +40,8 @@ namespace sgpem
void update(const History& history);
protected:
virtual void on_realize();
virtual void on_size_allocate(const Gtk::Allocation& allocation);
virtual void on_realize();
virtual void on_size_allocate(const Gtk::Allocation& allocation);
virtual void on_size_request(Gtk::Requisition* requisition);
virtual bool on_expose_event(GdkEventExpose* event);
virtual bool on_button_press_event(GdkEventButton* event);
@ -53,7 +53,7 @@ namespace sgpem
typedef std::pair<area_t, method0_t> area_callback_t;
typedef std::vector<area_callback_t> areas_vect_t;
private:
private:
// The height the widget will assume, must be determined
// before starting drawing by calc_height()
unsigned int _h;

63
src/gui_builder.cc
View file

@ -48,56 +48,55 @@ test_me()
GuiBuilder::GuiBuilder(const std::string& gladefile)
: _refXml(Xml::create(gladefile))
: _refXml(Xml::create(gladefile))
{
using namespace Gtk;
using namespace Gtk;
Window& main_window = get_initial_window();
Window& main_window = get_initial_window();
// Connect extra signals (decide where to do this...
// here -- ugly -- derive widgets and then use
// Glade::Xml::get_widget_derived -- better --)
MenuItem* file_quit = NULL;
_refXml->get_widget("MenuItem.File.Quit", file_quit);
file_quit->signal_activate().connect(sigc::ptr_fun(&Main::quit));
// Connect extra signals (decide where to do this...
// here -- ugly -- derive widgets and then use
// Glade::Xml::get_widget_derived -- better --)
MenuItem* file_quit = NULL;
_refXml->get_widget("MenuItem.File.Quit", file_quit);
file_quit->signal_activate().connect(sigc::ptr_fun(&Main::quit));
// About dialog
MenuItem* help_about = NULL;
_refXml->get_widget("MenuItem.Help.About", help_about);
AboutDialog* about_dialog = NULL;
_refXml->get_widget("AboutDialog", about_dialog);
//help_about->signal_activate().connect(sigc::mem_fun(*about_dialog, &Window::show));
// About dialog
MenuItem* help_about = NULL;
_refXml->get_widget("MenuItem.Help.About", help_about);
AboutDialog* about_dialog = NULL;
_refXml->get_widget("AboutDialog", about_dialog);
//help_about->signal_activate().connect(sigc::mem_fun(*about_dialog, &Window::show));
help_about->signal_activate().connect(sigc::ptr_fun(test_me));
// Temporary code to test the Schedulables custom widget
Expander* scheds_expander = NULL;
_refXml->get_widget("SchedulablesExpander", scheds_expander);
SchedulablesWidget* scheds_widget = manage(new SchedulablesWidget());
scheds_expander->add(*scheds_widget);
// we have to remember to manually show custom added widgets:
scheds_widget->show();
// Temporary code to test the Schedulables custom widget
Expander* scheds_expander = NULL;
_refXml->get_widget("SchedulablesExpander", scheds_expander);
SchedulablesWidget* scheds_widget = manage(new SchedulablesWidget());
scheds_expander->add(*scheds_widget);
// we have to remember to manually show custom added widgets:
scheds_widget->show();
}
GuiBuilder::~GuiBuilder()
{
}
GuiBuilder::~GuiBuilder()
{}
Gtk::Window&
GuiBuilder::get_initial_window() const
{
Gtk::Window* main_window = NULL;
_refXml->get_widget("MainWindow", main_window);
return *main_window;
Gtk::Window* main_window = NULL;
_refXml->get_widget("MainWindow", main_window);
return *main_window;
}
void
void
GuiBuilder::open_file(const std::string& filename)
{
// FIXME: to be written.
// Debug line (erase me when done):
std::cout << _("Filename to open: ") << filename << std::endl;
// FIXME: to be written.
// Debug line (erase me when done):
std::cout << _("Filename to open: ") << filename << std::endl;
}

31
src/gui_builder.hh
View file

@ -29,22 +29,23 @@
#include <string>
/** \brief This class initialize and starts the whole GUI
*/
namespace sgpem {
class GuiBuilder
{
public:
GuiBuilder(const std::string& gladefile = GLADEDIR "/main-window.glade");
~GuiBuilder();
Gtk::Window& get_initial_window() const;
void open_file(const std::string& filename);
private:
Glib::RefPtr<Gnome::Glade::Xml> _refXml;
};
*/
namespace sgpem
{
class GuiBuilder
{
public:
GuiBuilder(const std::string& gladefile = GLADEDIR "/main-window.glade");
~GuiBuilder();
Gtk::Window& get_initial_window() const;
void open_file(const std::string& filename);
private:
Glib::RefPtr<Gnome::Glade::Xml> _refXml;
};
} //~ namespace sgpem

2
src/main.cc
View file

@ -53,6 +53,6 @@ main(int argc, char* argv[])
// Parses options and prepares vector with
// filenames of documents to be opened
parse_options(argc, argv);
return 0;
}

136
src/parse_opts.cc
View file

@ -48,9 +48,9 @@ parse_options(int argc, char** argv)
using Glib::OptionGroup;
print_license();
// Prepare the option entries
OptionEntry no_gui;
OptionEntry policies_dir;
OptionEntry modules_dir;
@ -63,99 +63,99 @@ parse_options(int argc, char** argv)
no_gui.set_long_name("no-gui");
policies_dir.set_long_name("policies-dir");
modules_dir.set_long_name("modules_dir");
filename.set_long_name(G_OPTION_REMAINING);
filename.set_long_name(G_OPTION_REMAINING);
no_gui.set_description(_("starts the program in command line mode"));
policies_dir.set_description(_("adds this directory to the default modules search path"));
modules_dir.set_description(_("adds this directory to default plugin search path"));
filename.set_description(_("a list of savefiles; only the first will be opened"));
modules_dir.set_description(_("adds this directory to default plugin search path"));
filename.set_description(_("a list of savefiles; only the first will be opened"));
// Places where araguments will be saved
bool no_gui_enabled = false;
OptionGroup::vecustrings policies_dir_val;
OptionGroup::vecustrings modules_dir_val;
OptionGroup::vecstrings fnames;
OptionGroup::vecstrings fnames;
no_gui.set_flags(OptionEntry::FLAG_NO_ARG);
filename.set_flags(OptionEntry::FLAG_FILENAME | OptionEntry::FLAG_OPTIONAL_ARG);
no_gui.set_flags(OptionEntry::FLAG_NO_ARG);
filename.set_flags(OptionEntry::FLAG_FILENAME | OptionEntry::FLAG_OPTIONAL_ARG);
// Create the only group
OptionGroup group("options", "options");
OptionGroup group("options", "options");
group.add_entry(no_gui, no_gui_enabled);
group.add_entry(policies_dir, policies_dir_val);
group.add_entry(modules_dir, modules_dir_val);
group.add_entry_filename(filename, fnames);
group.add_entry_filename(filename, fnames);
// Create context
// Create context
OptionContext context(_("SGPEMv2, a graphical simulator for process "
"scheduling in a multitasking computer"));
"scheduling in a multitasking computer"));
context.set_main_group(group);
context.set_help_enabled(true);
context.set_ignore_unknown_options(false);
try
{
// Parse options, initialising the Gtk::Main at the same time
Gtk::Main main_loop(argc, argv, context);
GlobalPreferences& prefs = GlobalPreferences::get_instance();
for(Glib::OptionGroup::vecustrings::const_iterator it = policies_dir_val.begin();
it != policies_dir_val.end(); ++it)
prefs.add_policies_dir(*it);
for(Glib::OptionGroup::vecustrings::const_iterator it = modules_dir_val.begin();
it != modules_dir_val.end(); ++it)
prefs.add_modules_dir(*it);
// Now that GlobalPreferences has been initialized properly,
// initialize plugins, too
vector<Module*> modules = PluginManager::get_instance().get_module_list();
{
// Parse options, initialising the Gtk::Main at the same time
Gtk::Main main_loop(argc, argv, context);
for(vector<Module*>::iterator it = modules.begin(); it != modules.end(); ++it)
(*it)->set_enabled(true);
GlobalPreferences& prefs = GlobalPreferences::get_instance();
vector<CPUPolicyManager*> managers = CPUPoliciesGatekeeper::get_instance().get_registered();
for (Glib::OptionGroup::vecustrings::const_iterator it = policies_dir_val.begin();
it != policies_dir_val.end(); ++it)
prefs.add_policies_dir(*it);
for(vector<CPUPolicyManager*>::iterator it = managers.begin(); it != managers.end(); ++it)
(*it)->init();
if(no_gui_enabled)
{
// We don't return to main, instead we
// initialize the command line version
// of sgpemv2
TextSimulation sim;
std::string str;
for (Glib::OptionGroup::vecustrings::const_iterator it = modules_dir_val.begin();
it != modules_dir_val.end(); ++it)
prefs.add_modules_dir(*it);
std::cout << std::endl << "% ";
while(getline(std::cin, str))
{
// Enter main loop
TextSimulation::parse_command(sim, str);
std::cout << std::endl << "% ";
}
}
else
{
GuiBuilder* gui = new GuiBuilder();
if(fnames.begin() != fnames.end())
gui->open_file(*fnames.begin());
main_loop.run(gui->get_initial_window());
delete gui;
}
} // ~ try
catch(Glib::OptionError e)
{
std::cout << _("Bad invocation: ") << e.what() << std::endl;
std::cout << _("Use the `-?' or `--help' option to see the help") << std::endl;
}
}
// Now that GlobalPreferences has been initialized properly,
// initialize plugins, too
vector<Module*> modules = PluginManager::get_instance().get_module_list();
for (vector<Module*>::iterator it = modules.begin(); it != modules.end(); ++it)
(*it)->set_enabled(true);
vector<CPUPolicyManager*> managers = CPUPoliciesGatekeeper::get_instance().get_registered();
for (vector<CPUPolicyManager*>::iterator it = managers.begin(); it != managers.end(); ++it)
(*it)->init();
if (no_gui_enabled)
{
// We don't return to main, instead we
// initialize the command line version
// of sgpemv2
TextSimulation sim;
std::string str;
std::cout << std::endl << "% ";
while (getline(std::cin, str))
{
// Enter main loop
TextSimulation::parse_command(sim, str);
std::cout << std::endl << "% ";
}
}
else
{
GuiBuilder* gui = new GuiBuilder();
if (fnames.begin() != fnames.end())
gui->open_file(*fnames.begin());
main_loop.run(gui->get_initial_window());
delete gui;
}
} // ~ try
catch (Glib::OptionError e)
{
std::cout << _("Bad invocation: ") << e.what() << std::endl;
std::cout << _("Use the `-?' or `--help' option to see the help") << std::endl;
}
}
void

4
src/parse_opts.hh
View file

@ -23,8 +23,8 @@
/** \brief Parses command line options
*
* Parses command line options and sets argv to the first filename
* given to the cmdline.
* Parses command line options and sets argv to the first filename
* given to the cmdline.
* If no filename is given, in the end argc will be 0.
*
* Else argc will contain the length of the remaining argv[].

12
src/schedulables_widget.cc
View file

@ -28,14 +28,12 @@ using namespace sgpem;
SchedulablesWidget::SchedulablesWidget()
: Glib::ObjectBase("sgpem_SchedulablesWidget"), CairoWidget()
{
}
: Glib::ObjectBase("sgpem_SchedulablesWidget"), CairoWidget()
{}
SchedulablesWidget::~SchedulablesWidget()
{
}
{}
void
@ -49,7 +47,7 @@ SchedulablesWidget::draw_widget(cairo_t* ctx)
Color red = { 1, 0, 0 };
Point center = { 25, 25 };
ce.draw_3dsphere(center, 20, red);
}

10
src/templates/deletor.tcc
View file

@ -27,11 +27,11 @@
namespace memory
{
template<typename T>
struct deletor : public std::unary_function<void, T*>
{
inline void operator()(T* o) { delete o; }
};
template<typename T>
struct deletor : public std::unary_function<void, T*>
{
inline void operator()(T* o) { delete o; }
};
} //~ namespace memory

2
src/templates/singleton.hh
View file

@ -44,7 +44,7 @@ namespace sgpem
* \return The instantiated object
*/
static Instantiated_class& get_instance();
protected:
static Glib::RecMutex SG_DLLLOCAL _mutex;

4
src/templates/singleton.tcc
View file

@ -34,8 +34,8 @@ template<typename Instantiated_class>
Instantiated_class&
sgpem::Singleton<Instantiated_class>::get_instance()
{
Glib::RecMutex::Lock lock(_mutex);
if(_instance == NULL)
Glib::RecMutex::Lock lock (_mutex);
if (_instance == NULL)
_instance = new Instantiated_class();
return *_instance;
}

14
src/templates/smartp.tcc
View file

@ -47,9 +47,9 @@ namespace memory
template<typename T, bool isArray>
smart_ptr<T, isArray>::~smart_ptr() throw()
{
if(--(_contents->rc) == 0)
if (--(_contents->rc) == 0)
{
if(_contents->ptr != 0)
if (_contents->ptr != 0)
!isArray ? delete _contents->ptr : delete [] _contents->ptr;
delete _contents;
}
@ -61,11 +61,11 @@ namespace memory
smart_ptr<T, isArray>&
smart_ptr<T, isArray>::operator=(const smart_ptr& sptr) throw()
{
if(this != &sptr && _contents != sptr._contents)
if (this != &sptr && _contents != sptr._contents)
{
if(--(_contents->rc) == 0)
if (--(_contents->rc) == 0)
{
if(_contents->ptr != 0)
if (_contents->ptr != 0)
!isArray ? delete _contents->ptr : delete [] _contents->ptr;
delete _contents;
}
@ -165,11 +165,11 @@ namespace memory
smart_ptr<T, isArray>::smart_ptr(const smart_ptr<U, isArray>& sptr)
throw(std::bad_cast)
{
if(!sptr._contents->ptr || dynamic_cast<T*>(sptr._contents->ptr) == 0)
if (!sptr._contents->ptr || dynamic_cast<T*>(sptr._contents->ptr) == 0)
throw std::bad_cast();
// I know, I know... this is Evil(TM):
_contents = reinterpret_cast<typename smart_ptr<T, isArray>::contents_type*>(sptr._contents);
_contents = reinterpret_cast<typename smart_ptr<T, isArray>::contents_type* > (sptr._contents);
(_contents->rc)++;
}

146
src/testsuite/stubs/history.cc
View file

@ -24,90 +24,90 @@
using namespace sgpem;
memory::smart_ptr<sgpem::DynamicSchedulable>
History::get_scheduled_at(int time) const
{
using namespace memory;
smart_ptr<DynamicSchedulable> scheduled_at = smart_ptr<DynamicSchedulable>();
if (0 <= time && time <= _total_time_elapsed)
{
smart_ptr<ReadyQueue> sl = get_simulation_status_at(time);
bool found = false;
bool invalid = sl == smart_ptr<ReadyQueue>();
for (uint i = 0; !found && !invalid && i < sl->size(); i++)
{
const DynamicSchedulable* ss = sl->get_item_at(i);
if ((bool)ss && ss->get_state() == DynamicSchedulable::state_running)
{
scheduled_at = smart_ptr<DynamicSchedulable>(new DynamicSchedulable(*(ss)));
found = true;
}
}
}
return scheduled_at;
}
memory::smart_ptr<sgpem::DynamicSchedulable>
History::get_scheduled_at(int time) const
{
using namespace memory;
smart_ptr<DynamicSchedulable> scheduled_at = smart_ptr<DynamicSchedulable>();
if (0 <= time && time <= _total_time_elapsed)
{
smart_ptr<ReadyQueue> sl = get_simulation_status_at(time);
bool found = false;
bool invalid = sl == smart_ptr<ReadyQueue>();
for (uint i = 0; !found && !invalid && i < sl->size(); i++)
{
const DynamicSchedulable* ss = sl->get_item_at(i);
if ((bool)ss && ss->get_state() == DynamicSchedulable::state_running)
{
scheduled_at = smart_ptr<DynamicSchedulable>(new DynamicSchedulable(*(ss)));
found = true;
}
}
}
return scheduled_at;
}
memory::smart_ptr<sgpem::ReadyQueue>
History::get_simulation_status_at(int time) const
{
using namespace memory;
smart_ptr<ReadyQueue> simulation_status_at = smart_ptr<ReadyQueue>();
if (0 <= time && time <= _total_time_elapsed)
{
if (_slice == memory::smart_ptr<Slice>())
std::cout<<"History::get_simulation_status_at.NULL.error";
else
simulation_status_at = memory::smart_ptr<ReadyQueue>
(
new ReadyQueue
(
*(_slice->get_simulation_status())
)
);
}
return simulation_status_at;
}
memory::smart_ptr<sgpem::ReadyQueue>
History::get_simulation_status_at(int time) const
{
using namespace memory;
smart_ptr<ReadyQueue> simulation_status_at = smart_ptr<ReadyQueue>();
if (0 <= time && time <= _total_time_elapsed)
{
if (_slice == memory::smart_ptr<Slice>())
std::cout << "History::get_simulation_status_at.NULL.error";
else
simulation_status_at = memory::smart_ptr<ReadyQueue>
(
new ReadyQueue
(
*(_slice->get_simulation_status())
)
);
}
return simulation_status_at;
}
int
History::get_current_time() const
{
return _total_time_elapsed;
}
int
History::get_current_time() const
{
return _total_time_elapsed;
}
void
History::enqueue_slice(const sgpem::ReadyQueue& status)
{
_slice = memory::smart_ptr<Slice>(new Slice(_total_time_elapsed, 1, status));
_total_time_elapsed++;
}
void
History::enqueue_slice(const sgpem::ReadyQueue& status)
{
_slice = memory::smart_ptr<Slice>(new Slice(_total_time_elapsed, 1, status));
_total_time_elapsed++;
}
void
History::truncate_at(int instant)
{
//std::cout << "\nRecreating a Singleton History";
_slice = memory::smart_ptr<Slice>();
_total_time_elapsed = -1;
}
void
History::truncate_at(int instant)
{
//std::cout << "\nRecreating a Singleton History";
_slice = memory::smart_ptr<Slice>();
_total_time_elapsed = -1;
}
History&
History::get_instance()
{
if (History::_instance == NULL)
History::_instance = new History();
return *History::_instance;
}
History&
History::get_instance()
{
if (History::_instance == NULL)
History::_instance = new History();
return *History::_instance;
}
History::History()
{
_slice = memory::smart_ptr<Slice>();
_total_time_elapsed = -1;
}
History::History()
{
_slice = memory::smart_ptr<Slice>();
_total_time_elapsed = -1;
}
History * History::_instance = NULL;
History * History::_instance = NULL;

76
src/testsuite/stubs/history.hh
View file

@ -52,58 +52,58 @@
namespace sgpem
{
/** an History stub, should only save the last state included.
/** an History stub, should only save the last state included.
*/
class History : public ObservedSubject
{
public:
/** Returns the DynamicSchedulable of the schedulable
* which was running at the time, if any.
*/
class History : public ObservedSubject
{
public:
memory::smart_ptr<sgpem::DynamicSchedulable>
get_scheduled_at(int time) const;
/** Returns the DynamicSchedulable of the schedulable
* which was running at the time, if any.
*/
memory::smart_ptr<sgpem::DynamicSchedulable>
get_scheduled_at(int time) const;
/** Returns the last recorded instant, but may raise an error.
*/
memory::smart_ptr<sgpem::ReadyQueue>
get_simulation_status_at(int time) const;
/** Returns the last recorded instant, but may raise an error.
*/
memory::smart_ptr<sgpem::ReadyQueue>
get_simulation_status_at(int time) const;
/** Returns the total time recorded.
*/
int
get_current_time() const;
/** Returns the total time recorded.
*/
int
get_current_time() const;
/** Extends the recorded history by one unit, overwriting the old value
*/
void
enqueue_slice(const sgpem::ReadyQueue& status);
/** Extends the recorded history by one unit, overwriting the old value
*/
void
enqueue_slice(const sgpem::ReadyQueue& status);
/** STUB: THIS FEATURE IS NOT AVAILABLE
*/
void
truncate_at(int instant);
/** STUB: THIS FEATURE IS NOT AVAILABLE
*/
void
truncate_at(int instant);
/** Returns the singleton instance.
*/
static History&
get_instance();
/** Returns the singleton instance.
*/
static History&
get_instance();
private:
History();
private:
History();
static History * _instance;
int _total_time_elapsed;
memory::smart_ptr<Slice> _slice;
};
static History * _instance;
int _total_time_elapsed;
memory::smart_ptr<Slice> _slice;
};
} //~ namespace sgpem

16
src/testsuite/stubs/policy_manager.cc
View file

@ -28,24 +28,24 @@ PolicyManager::PolicyManager()
PolicyManager&
PolicyManager::get_registered_manager()
{
if (_registered == NULL)
_registered = new PolicyManager();
return *_registered;
if (_registered == NULL)
_registered = new PolicyManager();
return *_registered;
}
Policy&
Policy&
PolicyManager::get_policy()
{
return PRRPolicy::get_instance();
return PRRPolicy::get_instance();
}
void
void
PolicyManager::init()
{}
PolicyManager::~PolicyManager()
PolicyManager::~PolicyManager()
{
if(_registered == this) _registered = NULL;
if (_registered == this) _registered = NULL;
}

34
src/testsuite/stubs/policy_manager.hh
View file

@ -45,29 +45,29 @@
namespace sgpem
{
/** A policyManager stub, provides access to the PRRPolicy.
*/
class PolicyManager
{
public:
/** A policyManager stub, provides access to the PRRPolicy.
*/
class PolicyManager
{
public:
PolicyManager();
PolicyManager();
static PolicyManager&
get_registered_manager();
static PolicyManager&
get_registered_manager();
virtual Policy&
get_policy();
virtual Policy&
get_policy();
virtual void
init();
virtual void
init();
virtual
~PolicyManager();
virtual
~PolicyManager();
private:
static PolicyManager* _registered;
};
private:
static PolicyManager* _registered;
};
}
#endif

72
src/testsuite/stubs/prrpolicy.cc
View file

@ -24,97 +24,97 @@ using namespace sgpem;
PRRPolicy::PRRPolicy()
{
_instance = this;
_instance = this;
}
PRRPolicy::PRRPolicy(int quantum)
: _quantum(quantum)
{
_instance = this;
_instance = this;
}
Policy&
PRRPolicy::get_instance()
{
if(_instance == NULL) _instance = new PRRPolicy(3); // quantum size
return *_instance;
if (_instance == NULL) _instance = new PRRPolicy(3); // quantum size
return *_instance;
}
PRRPolicy::~PRRPolicy()
{}
void
void
PRRPolicy::configure()
throw(UserInterruptException)
throw(UserInterruptException)
{}
void
void
PRRPolicy::sort_queue() const
throw(UserInterruptException)
throw(UserInterruptException)
{
ReadyQueue* local_sl = Scheduler::get_instance().get_ready_queue();
for (uint useless = 0; useless < local_sl->size(); useless++)
for (uint i = 0; i < local_sl->size() - 1; i++)
if
(
local_sl->get_item_at(i)->get_schedulable()->get_priority() >
local_sl->get_item_at(i + 1)->get_schedulable()->get_priority()
)
local_sl->swap(i, i + 1);
ReadyQueue* local_sl = Scheduler::get_instance().get_ready_queue();
for (uint useless = 0; useless < local_sl->size(); useless++)
for (uint i = 0; i < local_sl->size() - 1; i++)
if
(
local_sl->get_item_at(i)->get_schedulable()->get_priority() >
local_sl->get_item_at(i + 1)->get_schedulable()->get_priority()
)
local_sl->swap(i, i + 1);
}
void
void
PRRPolicy::activate()
{}
void
void
PRRPolicy::deactivate()
{}
int
int
PRRPolicy::get_id() const
{
return 42;
return 42;
}
sgpem::policy_sorts_type
sgpem::policy_sorts_type
PRRPolicy::wants() const
throw(UserInterruptException)
throw(UserInterruptException)
{
return policy_sorts_processes;
return policy_sorts_processes;
}
Glib::ustring
Glib::ustring
PRRPolicy::get_name() const
{
return "42";
return "42";
}
Glib::ustring
Glib::ustring
PRRPolicy::get_description() const
{
return "42";
return "42";
}
bool
bool
PRRPolicy::is_pre_emptive() const
throw(UserInterruptException)
throw(UserInterruptException)
{
return 1;
return 1;
}
int
int
PRRPolicy::get_time_slice() const
throw(UserInterruptException)
throw(UserInterruptException)
{
return _quantum;
return _quantum;
}
PolicyParameters&
PolicyParameters&
PRRPolicy::get_parameters()
{
return _parameters;
return _parameters;
}
Policy*

118
src/testsuite/stubs/prrpolicy.hh
View file

@ -48,81 +48,81 @@
namespace sgpem
{
/** An hard-coded Priority Round Robin policy
* It's actually called PRRPolicy, altough my personal taste would have suggested
* naming it
* Prioriy-Reliant Roughly-Realized Recently-Reimplemented Round-Robin Policy,
* i.e. PRRRRRRR-Policy.
* it adds a new constructor taking the quantum size (time slice)
*/
class PRRPolicy : public Policy
{
public:
/** An hard-coded Priority Round Robin policy
* It's actually called PRRPolicy, altough my personal taste would have suggested
* naming it
* Prioriy-Reliant Roughly-Realized Recently-Reimplemented Round-Robin Policy,
* i.e. PRRRRRRR-Policy.
* it adds a new constructor taking the quantum size (time slice)
*/
class PRRPolicy : public Policy
{
public:
PRRPolicy();
PRRPolicy();
PRRPolicy(int quantum);
PRRPolicy(int quantum);
static Policy&
get_instance();
virtual
~PRRPolicy();
static Policy&
get_instance();
virtual void
configure()
throw(UserInterruptException);
virtual
~PRRPolicy();
virtual void
sort_queue() const
throw(UserInterruptException);
virtual void
configure()
throw(UserInterruptException);
virtual void
sort_queue() const
throw(UserInterruptException);
virtual void
activate();
virtual void
activate();
virtual void
deactivate();
virtual int
get_id() const;
virtual sgpem::policy_sorts_type
wants() const
throw(UserInterruptException);
virtual Glib::ustring
get_name() const;
virtual Glib::ustring
get_description() const;
virtual bool
is_pre_emptive() const
throw(UserInterruptException);
virtual int
get_time_slice() const
throw(UserInterruptException);
virtual void
deactivate();
virtual PolicyParameters&
get_parameters();
virtual int
get_id() const;
virtual sgpem::policy_sorts_type
wants() const
throw(UserInterruptException);
virtual Glib::ustring
get_name() const;
virtual Glib::ustring
get_description() const;
virtual bool
is_pre_emptive() const
throw(UserInterruptException);
virtual int
get_time_slice() const
throw(UserInterruptException);
virtual PolicyParameters&
get_parameters();
protected:
protected:
PolicyParameters _parameters;
int _id;
int _quantum;
PolicyParameters _parameters;
int _id;
int _quantum;
private:
private:
static Policy* _instance;
};
static Policy* _instance;
};
}

37
src/testsuite/test-global_preferences_serialization.cc
View file

@ -32,33 +32,34 @@
// from here and further until the bottom, all to throw away I suppose
int
main(int argc, char** argv) {
main(int argc, char** argv)
{
using namespace sgpem;
using Glib::ustring;
using std::cout;
using std::endl;
using std::ostringstream;
GlobalPreferences& gp = GlobalPreferences::get_instance();
if(argc<2)
if (argc < 2)
{
cout << "GlobalPreferences serialization test program" << endl;
cout << "Syntax: test-global_preferences_serialization [mod1 mod2 ...][% pol1 pol2 ...]" << endl << endl;
cout << "This test add modules directories (mod1 mod2 ...) and modules directories (mod1 mod2 ...)" << endl
<< "to GlobalPreferences, write it to the configuration file " << gp.get_config_filename()
<< ", read it and compare with saved one." << endl << endl;
<< "to GlobalPreferences, write it to the configuration file " << gp.get_config_filename()
<< ", read it and compare with saved one." << endl << endl;
}
int i=1;
while(i<argc && (*argv[i]!='%'))
int i = 1;
while (i < argc && (*argv[i] != '%'))
{
gp.add_modules_dir( Glib::ustring(argv[i]) );
i++;
}
i++;
while(i<argc)
while (i < argc)
{
gp.add_policies_dir( Glib::ustring(argv[i]) );
i++;
@ -78,19 +79,19 @@ main(int argc, char** argv) {
gp.write_configrc(os1);
i=1;
while(i<argc && (*argv[i]!='%'))
i = 1;
while (i < argc && (*argv[i] != '%'))
{
gp.add_modules_dir( Glib::ustring("bis-") + Glib::ustring(argv[i]) );
i++;
}
i++;
while(i<argc)
while (i < argc)
{
gp.add_policies_dir( Glib::ustring("bis-") + Glib::ustring(argv[i]) );
i++;
}
cout << "Other data added" << endl << endl;
gp.write_configrc(cout);
@ -107,13 +108,13 @@ main(int argc, char** argv) {
ostringstream os3;
cout << "Preferences writed into os3 (t3)" << endl << endl;
gp.write_configrc(os3);
cout << "Comparing dump of (t1) and (t2): " << (os1.str()==os2.str()?"equals":"not equals") << endl;
cout << "Comparing dump of (t1) and (t3): " << (os1.str()==os3.str()?"equals":"not equals") << endl;
cout << "Comparing dump of (t1) and (t2): " << (os1.str() == os2.str() ? "equals" : "not equals") << endl;
cout << "Comparing dump of (t1) and (t3): " << (os1.str() == os3.str() ? "equals" : "not equals") << endl;
int ret = 1;
if(os1.str()!=os2.str()
&& os1.str()==os3.str())
if (os1.str() != os2.str()
&& os1.str() == os3.str())
{
cout << "test successful" << endl;
ret = 0;

320
src/testsuite/test-history.cc
View file

@ -42,13 +42,13 @@ using Glib::ustring;
// it is updated
class DummyObserver : public HistoryObserver
{
public:
DummyObserver() : _i(0) {}
void update(const History& history)
{
cout << "Observer.update() : " << ++_i << endl;
}
unsigned int _i;
public:
DummyObserver() : _i(0) {}
void update(const History& history)
{
cout << "Observer.update() : " << ++_i << endl;
}
unsigned int _i;
};
struct ProcessCreationData
@ -87,25 +87,25 @@ struct SubRequestCreationData
History::resource_key_t resource_key;
time_t duration;
};
DynamicThread&
find_thread(ConcreteEnvironment& env, Thread& _thread)
{
DynamicThread& thread = (DynamicThread&)_thread;
Environment::Processes& processes = env.get_processes();
// please forgive me, I'm sick of using iterators...
for(unsigned int i = 0; i < processes.size(); ++i)
for (unsigned int i = 0; i < processes.size(); ++i)
{
Process& p = *processes[i];
vector<Thread*> threads = p.get_threads();
for(unsigned int j = 0; j < threads.size(); ++j)
for (unsigned int j = 0; j < threads.size(); ++j)
{
DynamicThread& t = (DynamicThread&)*threads[j];
if(t == thread)
return t;
DynamicThread& t = (DynamicThread&) * threads[j];
if (t == thread)
return t;
}
}
@ -117,18 +117,18 @@ find_thread(const ConcreteEnvironment& env, const Thread& _thread)
{
const DynamicThread& thread = (DynamicThread&)_thread;
const Environment::Processes& processes = env.get_processes();
// please forgive me, I'm sick of using iterators...
for(unsigned int i = 0; i < processes.size(); ++i)
for (unsigned int i = 0; i < processes.size(); ++i)
{
const Process& p = *processes[i];
vector<const Thread*> threads = p.get_threads();
for(unsigned int j = 0; j < threads.size(); ++j)
for (unsigned int j = 0; j < threads.size(); ++j)
{
const DynamicThread& t = (const DynamicThread&)*threads[j];
if(t == thread)
return t;
const DynamicThread& t = (const DynamicThread&) * threads[j];
if (t == thread)
return t;
}
}
@ -140,7 +140,7 @@ main(int argc, char** argv)
{
ostream& info = cout;
ostream& test = cerr;
using namespace sgpem;
ConcreteHistory h;
@ -148,20 +148,20 @@ main(int argc, char** argv)
info << "Created the ConcreteHistory instance\n";
test << "Checking if it contains only one Environment... ";
if(h.get_size() == 1)
if (h.get_size() == 1)
test << "PASS";
else
test << "FAIL";
test << endl;
const ConcreteEnvironment& environment = h.get_last_environment();
info << "Obtained the only contained environment\n";
test << "Checking if the environment is empty... ";
if(environment.get_processes().size() == 0 &&
if (environment.get_processes().size() == 0 &&
environment.get_resources().size() == 0 &&
environment.get_sorted_queue().size() == 0)
test << "PASS";
@ -172,101 +172,101 @@ main(int argc, char** argv)
DummyObserver observer;
info << "Created the observer\n";
h.attach(observer);
info << "Attached to the history\n";
const ProcessCreationData processes[2] =
{
{ "p1", 0, 3 },
{ "p2", 3, 1 }
};
const ProcessCreationData processes[2] =
{
{ "p1", 0, 3 },
{ "p2", 3, 1 }
};
DynamicProcess& p1 = h.add_process(processes[0].name,
processes[0].arrival_time,
processes[0].base_priority);
DynamicProcess& p1 = h.add_process(processes[0].name,
processes[0].arrival_time,
processes[0].base_priority);
DynamicProcess& p2 = h.add_process(processes[1].name,
processes[1].arrival_time,
processes[1].base_priority);
DynamicProcess& p2 = h.add_process(processes[1].name,
processes[1].arrival_time,
processes[1].base_priority);
const ThreadCreationData threads[4] =
{
{ "p2_1", &p2, 3, 0, 0 },
{ "p1_1", &p1, 2, 0, 2 },
{ "p1_2", &p1, 1, 1, 0 },
{ "p2_2", &p2, 5, 3, 1 }
};
const ThreadCreationData threads[4] =
{
{ "p2_1", &p2, 3, 0, 0 },
{ "p1_1", &p1, 2, 0, 2 },
{ "p1_2", &p1, 1, 1, 0 },
{ "p2_2", &p2, 5, 3, 1 }
};
DynamicThread& p2_1 = h.add_thread(threads[0].name,
*threads[0].parent,
threads[0].cpu_time,
threads[0].arrival_time,
threads[0].base_priority);
*threads[0].parent,
threads[0].cpu_time,
threads[0].arrival_time,
threads[0].base_priority);
DynamicThread& p1_1 = h.add_thread(threads[1].name,
*threads[1].parent,
threads[1].cpu_time,
threads[1].arrival_time,
threads[1].base_priority);
*threads[1].parent,
threads[1].cpu_time,
threads[1].arrival_time,
threads[1].base_priority);
DynamicThread& p1_2 = h.add_thread(threads[2].name,
*threads[2].parent,
threads[2].cpu_time,
threads[2].arrival_time,
threads[2].base_priority);
DynamicThread& p2_2 = h.add_thread(threads[3].name,
*threads[3].parent,
threads[3].cpu_time,
threads[3].arrival_time,
threads[3].base_priority);
*threads[2].parent,
threads[2].cpu_time,
threads[2].arrival_time,
threads[2].base_priority);
const ResourceCreationData resources[2] =
{
{ "res1", true, 2, 0 },
{ "res2", false, 1, 0 }
};
DynamicThread& p2_2 = h.add_thread(threads[3].name,
*threads[3].parent,
threads[3].cpu_time,
threads[3].arrival_time,
threads[3].base_priority);
const ResourceCreationData resources[2] =
{
{ "res1", true, 2, 0 },
{ "res2", false, 1, 0 }
};
const History::ResourcePair res1 = h.add_resource(resources[0].name,
resources[0].preemptable,
resources[0].places,
resources[0].availability);
const History::ResourcePair res2 = h.add_resource(resources[1].name,
resources[1].preemptable,
resources[1].places,
resources[1].availability);
resources[0].preemptable,
resources[0].places,
resources[0].availability);
const RequestCreationData requests[2] =
{
{ &p1_2, 0 },
{ &p2_1, 1 }
};
const History::ResourcePair res2 = h.add_resource(resources[1].name,
resources[1].preemptable,
resources[1].places,
resources[1].availability);
const RequestCreationData requests[2] =
{
{ &p1_2, 0 },
{ &p2_1, 1 }
};
DynamicRequest& req1 = h.add_request(*requests[0].owner, requests[0].instant);
DynamicRequest& req2 = h.add_request(*requests[1].owner, requests[1].instant);
const SubRequestCreationData subrequests[3] =
{
{ &req1, res1.first, 1 },
{ &req2, res2.first, 2 },
{ &req2, res1.first, 1 }
};
const SubRequestCreationData subrequests[3] =
{
{ &req1, res1.first, 1 },
{ &req2, res2.first, 2 },
{ &req2, res1.first, 1 }
};
const DynamicSubRequest& sreq1 = h.add_subrequest(*subrequests[0].request,
subrequests[0].resource_key,
subrequests[0].duration);
subrequests[0].resource_key,
subrequests[0].duration);
const DynamicSubRequest& sreq2 = h.add_subrequest(*subrequests[1].request,
subrequests[1].resource_key,
subrequests[1].duration);
subrequests[1].resource_key,
subrequests[1].duration);
const DynamicSubRequest& sreq3 = h.add_subrequest(*subrequests[2].request,
subrequests[2].resource_key,
subrequests[2].duration);
subrequests[2].resource_key,
subrequests[2].duration);
info << "Done adding required data by using the History factory interface\n";
@ -275,7 +275,7 @@ main(int argc, char** argv)
// const Environment::SubRequestQueue res2_queue = environment.get_request_queue(res2.first);
test << "Checking if the environment contains the correct request queues... ";
typedef Environment::SubRequestQueue::const_iterator ReqIterator;
// ************* FIXME *************** :
@ -286,15 +286,15 @@ main(int argc, char** argv)
// bool res1_req2_match = false;
// bool res2_req1_match = false;
// bool bad_match = false;
// for(ReqIterator it = res1_queue.begin(); it != res1_queue.end(); ++it)
// {
// if(!res1_req1_match && *it == &req1)
// res1_req1_match = true;
// res1_req1_match = true;
// else if(!res1_req2_match && *it == &req2)
// res1_req2_match == true;
// res1_req2_match == true;
// else
// bad_match = true;
// bad_match = true;
// }
// if(!res2_req1_match && *res2_queue.begin() == &req1)
@ -309,25 +309,25 @@ main(int argc, char** argv)
// }
// else
// test << "FAIL";
test << endl;
test << endl;
ConcreteEnvironment* environment1 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment2 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment3 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment4 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment5 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment1 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment2 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment3 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment4 = new ConcreteEnvironment(environment);
ConcreteEnvironment* environment5 = new ConcreteEnvironment(environment);
info << "Created 5 copies of inital environment\n";
const History::prio_t priorities[5] = { 3, 1, 4, 5, 2 };
find_thread(*environment1, p1_1).set_priority_push(priorities[0]);
find_thread(*environment2, p1_1).set_priority_push(priorities[1]);
find_thread(*environment3, p1_1).set_priority_push(priorities[2]);
find_thread(*environment4, p1_1).set_priority_push(priorities[3]);
find_thread(*environment5, p1_1).set_priority_push(priorities[4]);
info << "Updated dynamic priority of threads\n";
h.append_new_environment(environment1);
@ -340,7 +340,7 @@ main(int argc, char** argv)
test << "Checking if history size is 6... ";
if(h.get_size() == 6)
if (h.get_size() == 6)
test << "PASS";
else
test << "FAIL";
@ -351,7 +351,7 @@ main(int argc, char** argv)
test << "Checking if dynamic priority of thread at instant 1 and 5 is different... ";
if(t1.get_priority_push() != t5.get_priority_push())
if (t1.get_priority_push() != t5.get_priority_push())
test << "PASS";
else
test << "FAIL";
@ -361,10 +361,10 @@ main(int argc, char** argv)
test << "Checking if dynamic priority of thread at instant 4, is different ";
test << "from that at instant 1 and 5, and equal to the one expected... ";
if(t4.get_priority_push() != t1.get_priority_push() &&
t4.get_priority_push() != t5.get_priority_push() &&
t4.get_priority_push() == priorities[3])
if (t4.get_priority_push() != t1.get_priority_push() &&
t4.get_priority_push() != t5.get_priority_push() &&
t4.get_priority_push() == priorities[3])
test << "PASS";
else
test << "FAIL";
@ -372,55 +372,55 @@ main(int argc, char** argv)
test << "Checking whether all subrequests in the last environment ";
test << "refer to valid resources... ";
const ConcreteEnvironment& last_env = h.get_last_environment();
const Environment::Processes& le_processes = last_env.get_processes();
const Environment::Resources& le_resources = last_env.get_resources();
bool subreq_pass = true;
for(unsigned int i = 0; i < le_processes.size(); ++i)
for (unsigned int i = 0; i < le_processes.size(); ++i)
{
vector<Thread*> threads = le_processes[i]->get_threads();
for(unsigned int j = 0; j < threads.size(); ++j)
for (unsigned int j = 0; j < threads.size(); ++j)
{
vector<Request*> requests = threads[j]->get_requests();
for(unsigned int k = 0; k < requests.size(); ++k)
for (unsigned int k = 0; k < requests.size(); ++k)
{
vector<SubRequest*> subrequests = requests[k]->get_subrequests();
vector<SubRequest*> subrequests = requests[k]->get_subrequests();
for(unsigned int x = 0; x < subrequests.size(); ++x)
{
if(le_resources.find(subrequests[x]->get_resource_key()) == le_resources.end())
subreq_pass = false;
}
for (unsigned int x = 0; x < subrequests.size(); ++x)
{
if (le_resources.find(subrequests[x]->get_resource_key()) == le_resources.end())
subreq_pass = false;
}
}
}
}
if(subreq_pass)
if (subreq_pass)
test << "PASS";
else
test << "FAIL";
test << endl;
test << "Checking if history throws an exception on accessing a nonexistent environment... ";
try
{
h.get_environment_at(6);
test << "FAIL";
}
catch(out_of_range)
catch (out_of_range)
{
test << "PASS";
}
test << endl;
ThreadCreationData p1_3_d = { "p1_3", &p1, 3, 4, 0 };
Thread& p1_3 = h.add_thread(p1_3_d.name,
*p1_3_d.parent,
p1_3_d.cpu_time,
@ -431,7 +431,7 @@ main(int argc, char** argv)
test << "Checking if history has size 1 after adding a thread... ";
if(h.get_size() == 1)
if (h.get_size() == 1)
test << "PASS";
else
test << "FAIL";
@ -442,12 +442,12 @@ main(int argc, char** argv)
h.append_new_environment(environment6);
info << "Added a new environment to the history as a clear-cut copy of the last" << endl;
h.remove(res1.first);
test << "Checking if history has size 1 after removing a resource... ";
if(h.get_size() == 1)
if (h.get_size() == 1)
test << "PASS";
else
test << "FAIL";
@ -456,7 +456,7 @@ main(int argc, char** argv)
test << "Checking whether objects inside the history are the same as the beginning, ";
test << "except for the missing thread and associated requests... ";
const Environment::Processes& final_processes = h.get_last_environment().get_processes();
const Environment::Resources& final_resources = h.get_last_environment().get_resources();
@ -464,57 +464,57 @@ main(int argc, char** argv)
bool final_p2_match = false;
bool final_bad_match = false;
bool final_sreq2_match = false;
for(unsigned int i = 0; i < final_processes.size(); ++i)
{
DynamicProcess& p = (DynamicProcess&)*final_processes[i];
if(!final_p1_match && p == p1)
for (unsigned int i = 0; i < final_processes.size(); ++i)
{
DynamicProcess& p = (DynamicProcess&) * final_processes[i];
if (!final_p1_match && p == p1)
final_p1_match = true;
else if(!final_p2_match && p == p2)
else if (!final_p2_match && p == p2)
final_p2_match = true;
else
final_bad_match = true;
vector<DynamicThread*>& threads = p.get_dynamic_threads();
for(unsigned int j = 0; j < threads.size(); ++j)
for (unsigned int j = 0; j < threads.size(); ++j)
{
vector<DynamicRequest*> requests = threads[j]->get_dynamic_requests();
for(unsigned int k = 0; k < requests.size(); ++k)
for (unsigned int k = 0; k < requests.size(); ++k)
{
vector<DynamicSubRequest*> subrequests = requests[k]->get_dynamic_subrequests();
vector<DynamicSubRequest*> subrequests = requests[k]->get_dynamic_subrequests();
for(unsigned int x = 0; x < subrequests.size(); ++x)
{
// NOTE this will of course fail if the subrequests which should not be here
// are still in the environment
if(!final_sreq2_match && *subrequests[x] == sreq2)
final_sreq2_match = true;
else
final_bad_match = true;
}
for (unsigned int x = 0; x < subrequests.size(); ++x)
{
// NOTE this will of course fail if the subrequests which should not be here
// are still in the environment
if (!final_sreq2_match && *subrequests[x] == sreq2)
final_sreq2_match = true;
else
final_bad_match = true;
}
}
}
}
typedef Environment::Resources::const_iterator ResourceIt;
if(final_resources.size() == 1)
if (final_resources.size() == 1)
{
DynamicResource& r = (DynamicResource&)*(final_resources.begin()->second);
if(!(r == *res2.second))
DynamicResource& r = (DynamicResource&) * (final_resources.begin()->second);
if (!(r == *res2.second))
final_bad_match = true;
}
else
final_bad_match = true;
if(!final_bad_match && final_p1_match && final_p2_match && final_sreq2_match)
if (!final_bad_match && final_p1_match && final_p2_match && final_sreq2_match)
test << "PASS";
else
test << "FAIL";
test << endl;
test << endl;
test << "Checking whether ConcreteHistory throws an exception if we try to use ";
@ -523,12 +523,12 @@ main(int argc, char** argv)
try
{
// FIXME This causes a warning because we force a conversion of a negative number
// to an unsigned integer. What did the designers wanted to test by doing this?
// to an unsigned integer. What did the designers wanted to test by doing this?
// The compiler?
h.get_environment_at(-17);
test << "FAIL";
}
catch(out_of_range)
catch (out_of_range)
{
test << "PASS";
}
@ -536,7 +536,7 @@ main(int argc, char** argv)
test << "Internal observer's counter should be 21... ";
if(observer._i == 21)
if (observer._i == 21)
test << "PASS";
else
test << "FAIL";

59
src/testsuite/test-key_file.cc
View file

@ -31,68 +31,69 @@
// from here and further until the bottom, all to throw away I suppose
int
main(int argc, char** argv) {
main(int argc, char** argv)
{
using namespace sgpem;
using Glib::ustring;
using std::cout;
using std::endl;
if((argc<4) || (argc%2)!=0)
if ((argc < 4) || (argc % 2) != 0)
{
cout << "KeyFile class test program" << endl;
cout << "Syntax: test-key_file filename key1 value1 [key2 value2...]" << endl;
cout << "total number of parameters must be odd."
<< endl << endl;
cout << "This test create a KeyFile object, fill it with all key/value pairs," << endl
<< "write it to the file \"filename\", read it into a new KeyFile object" << endl
<< "and compare all readed values against original values." << endl << endl
<< "If all key/values match the program print \"Test was successful\" and return 0." << endl
<< "If some key/values doesn't match the program print \"Test failed\" and return 1."
<< endl << endl;
cout << "If there isn't any parameter or bad number of parameters return 2."
<< endl << endl;
cout << "NOTE: 1) Test fails with invalid filenames or duplicated key in input."
<< endl;
cout << " 2) File \"filename\" remains in current directory after test execution."
<< endl << endl;
cout << "total number of parameters must be odd."
<< endl << endl;
cout << "This test create a KeyFile object, fill it with all key/value pairs," << endl
<< "write it to the file \"filename\", read it into a new KeyFile object" << endl
<< "and compare all readed values against original values." << endl << endl
<< "If all key/values match the program print \"Test was successful\" and return 0." << endl
<< "If some key/values doesn't match the program print \"Test failed\" and return 1."
<< endl << endl;
cout << "If there isn't any parameter or bad number of parameters return 2."
<< endl << endl;
cout << "NOTE: 1) Test fails with invalid filenames or duplicated key in input."
<< endl;
cout << " 2) File \"filename\" remains in current directory after test execution."
<< endl << endl;
return 2;
}
KeyFile kfile;
KeyFile kfile_bis;
// fill KeyFile object
for(int index = 2; index<argc; index+=2)
// fill KeyFile object
for (int index = 2; index < argc; index += 2)
{
kfile.insert_key_value(Glib::ustring(argv[index]), Glib::ustring(argv[index+1]));
}
// write KeyFile object to file
kfile.file_write(Glib::ustring(argv[1]));
// read new KeyFile object from file
kfile_bis.file_read(Glib::ustring(argv[1]));
// compare writed vs. readed data
bool ok = true;
for(int index = 2; ok && index<argc; index+=2)
for (int index = 2; ok && index < argc; index += 2)
{
Glib::ustring val(argv[index+1]);
const Glib::ustring* pt = kfile_bis.search_value(Glib::ustring(argv[index]));
if(!pt || (*pt)!=val)
if (!pt || (*pt) != val)
{
ok = false;
}
}
// output response...
if(ok)
if (ok)
{
cout << "Test successful" << endl;
return 0;
}
else
else
{
cout << "Test failed" << endl;
return 1;

2
src/testsuite/test-parse_command.cc
View file

@ -89,7 +89,7 @@ namespace sgpem
History&
TestHistory::get_instance()
{
if(!_instance)
if (!_instance)
_instance = new TestHistory();
return *_instance;
}

7
src/testsuite/test-stepforward.cc
View file

@ -69,7 +69,7 @@ namespace sgpem
static Policy& get_instance()
{
if(!_instance) _instance = new Policy(3); // quantum size
if (!_instance) _instance = new Policy(3); // quantum size
return *_instance;
}
@ -167,7 +167,7 @@ namespace sgpem
PolicyManager::~PolicyManager()
{
if(_registered == this) _registered = NULL;
if (_registered == this) _registered = NULL;
}
PolicyManager&
@ -199,7 +199,7 @@ namespace sgpem
History::get_instance()
{
if(!_instance) _instance = new Policy(3); // quantum size
if (!_instance) _instance = new Policy(3); // quantum size
return *_instance;
}
@ -213,7 +213,6 @@ namespace sgpem
// this class should invoke the Scheduler Stepforward method.
class StepForwardTester
{
}
// from here and further until the bottom, all to throw away I suppose

822
src/text_simulation.cc
View file

File diff suppressed because it is too large Load diff

8
src/text_simulation.hh
View file

@ -84,7 +84,7 @@ namespace sgpem
void on_stop(const Tokens& arguments);
void on_configure_cpu_policy(const Tokens& arguments);
void on_help(const Tokens& arguments);
void on_quit(const Tokens& arguments);
void on_quit(const Tokens& arguments);
void on_get(const Tokens& arguments);
void on_set(const Tokens& arguments);
void on_show(const Tokens& arguments);
@ -101,7 +101,7 @@ namespace sgpem
void on_add_thread(const Tokens& arguments);
void on_add_request(const Tokens& arguments);
void on_add_subrequest(const Tokens& arguments);
void on_remove(const Tokens& arguments);
void on_remove(const Tokens& arguments);
void on_remove_process(const Tokens& arguments);
void on_remove_resource(const Tokens& arguments);
void on_remove_thread(const Tokens& arguments);
@ -109,8 +109,8 @@ namespace sgpem
void on_remove_subrequest(const Tokens& arguments);
void on_save(const Tokens& arguments);
void on_load(const Tokens& arguments);
// FIXME This is a temporary replacement for the
// FIXME This is a temporary replacement for the
// to-be written I/O layer
static void p_stdout(const Glib::ustring& str);
static void p_stderr(const Glib::ustring& str);