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

- Add down_cast<> to safely checking dynamic_casts when in development. Be sure to read its documentation before use\! 

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@1188 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
tchernobog 2006-09-16 11:21:06 +00:00
parent f1954c9f71
commit deaf0702e5
3 changed files with 178 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

@ -436,6 +436,7 @@ EXTRA_DIST += $(glade_DATA)
templates_HEADERS += \
src/backend/sgpemv2/templates/deletor.tcc \
src/backend/sgpemv2/templates/down_cast.tcc \
src/backend/sgpemv2/templates/parameter.tcc \
src/backend/sgpemv2/templates/sequences.tcc \
src/backend/sgpemv2/templates/singleton.hh \

34
src/backend/concrete_history.cc
View File

@ -32,9 +32,11 @@
#include "static_request.hh"
#include "static_sub_request.hh"
#include <sgpemv2/history_observer.hh>
#include "concrete_history.hh"
#include <sgpemv2/history_observer.hh>
#include <sgpemv2/templates/down_cast.tcc>
#include <sgpemv2/templates/deletor.tcc>
#include <sgpemv2/templates/smartp.tcc>
@ -170,7 +172,7 @@ ConcreteHistory::remove(resource_key_t resource_key)
typedef ConcreteEnvironment::Processes::iterator ProcIt;
for (ProcIt it1 = processes.begin(); it1 != processes.end(); it1++)
{
Threads& threads = dynamic_cast<DynamicProcess&>(**it1).get_dynamic_threads();
Threads& threads = down_cast<DynamicProcess&>(**it1).get_dynamic_threads();
for (Threads::iterator it2 = threads.begin(); it2 != threads.end(); it2++)
{
Requests& reqs = (*it2)->get_dynamic_requests();
@ -212,7 +214,7 @@ ConcreteHistory::remove(Process& process)
void
ConcreteHistory::remove(Thread& thread)
{
DynamicThread& dyn_thr = dynamic_cast<DynamicThread&>(thread);
DynamicThread& dyn_thr = down_cast<DynamicThread&>(thread);
// Pay attention that initial isn't deleted by reset()
ConcreteEnvironment& initial = *_snapshots.front();
@ -223,7 +225,7 @@ ConcreteHistory::remove(Thread& thread)
if (found == NULL)
return; // not found, just return.
DynamicProcess& dynamic_found = dynamic_cast<DynamicProcess&>(*found);
DynamicProcess& dynamic_found = down_cast<DynamicProcess&>(*found);
bool removed = deep_remove<DynamicThread>(dynamic_found.get_dynamic_threads(), dyn_thr);
if (removed)
@ -234,7 +236,7 @@ ConcreteHistory::remove(Thread& thread)
void
ConcreteHistory::remove(Request& request)
{
DynamicRequest& dyn_req = dynamic_cast<DynamicRequest&>(request);
DynamicRequest& dyn_req = down_cast<DynamicRequest&>(request);
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
@ -243,7 +245,7 @@ ConcreteHistory::remove(Request& request)
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* proc_ref = deep_find<Process>(processes, dyn_proc);
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
DynamicProcess* dyn_proc_ref = down_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);
@ -263,7 +265,7 @@ 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);
DynamicSubRequest& dyn_sub = down_cast<DynamicSubRequest&>(subrequest);
DynamicRequest& dyn_req = dyn_sub.get_request();
DynamicThread& dyn_thr = dyn_req.get_thread();
DynamicProcess& dyn_proc = dyn_thr.get_process();
@ -273,7 +275,7 @@ ConcreteHistory::remove(SubRequest& subrequest)
ConcreteEnvironment::Processes& processes = initial.get_processes();
Process* proc_ref = deep_find<Process>(processes, dyn_proc);
DynamicProcess* dyn_proc_ref = dynamic_cast<DynamicProcess*>(proc_ref);
DynamicProcess* dyn_proc_ref = down_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);
@ -346,7 +348,7 @@ ConcreteHistory::edit_resource(Resource& resource,
{
// And preemptable and availability?? FIXME!
DynamicResource* res = dynamic_cast<DynamicResource*>(&resource);
DynamicResource* res = down_cast<DynamicResource*>(&resource);
StaticResource& core = res->get_core();
core.set_name(name);
core.set_places(places);
@ -379,7 +381,7 @@ ConcreteHistory::edit_process(Process& process,
time_t arrival_time,
prio_t base_priority)
{
DynamicProcess* proc = dynamic_cast<DynamicProcess*>(&process);
DynamicProcess* proc = down_cast<DynamicProcess*>(&process);
StaticProcess& core = proc->get_core();
core.set_name(name);
core.set_arrival_time(arrival_time);
@ -399,7 +401,7 @@ ConcreteHistory::add_thread(const Glib::ustring& name,
{
reset(false);
DynamicProcess& parent_process = dynamic_cast<DynamicProcess&>(parent);
DynamicProcess& parent_process = down_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);
@ -415,7 +417,7 @@ ConcreteHistory::edit_thread(Thread& thread,
time_t arrival_time,
prio_t base_priority)
{
DynamicThread* thre = dynamic_cast<DynamicThread*>(&thread);
DynamicThread* thre = down_cast<DynamicThread*>(&thread);
StaticThread& core = thre->get_core();
core.set_name(name);
core.set_total_cpu_time(cpu_time);
@ -431,7 +433,7 @@ ConcreteHistory::add_request(Thread& owner,
{
reset(false);
DynamicThread& dyn_owner = dynamic_cast<DynamicThread&>(owner);
DynamicThread& dyn_owner = down_cast<DynamicThread&>(owner);
StaticThread& owner_core = dyn_owner.get_core();
StaticRequest* core = new StaticRequest(&owner_core, instant);
@ -447,7 +449,7 @@ void
ConcreteHistory::edit_request(Request& request,
time_t instant)
{
DynamicRequest* req = dynamic_cast<DynamicRequest*>(&request);
DynamicRequest* req = down_cast<DynamicRequest*>(&request);
StaticRequest& core = req->get_core();
core.set_instant(instant);
@ -462,7 +464,7 @@ ConcreteHistory::add_subrequest(Request& request,
{
reset(false);
DynamicRequest& dyn_request = dynamic_cast<DynamicRequest&>(request);
DynamicRequest& dyn_request = down_cast<DynamicRequest&>(request);
StaticSubRequest* core = new StaticSubRequest(resource_key, duration);
DynamicSubRequest* subreq = new DynamicSubRequest(core, &dyn_request);
@ -478,7 +480,7 @@ ConcreteHistory::edit_subrequest(SubRequest& subrequest,
resource_key_t resource_key,
time_t duration)
{
DynamicSubRequest* sreq = dynamic_cast<DynamicSubRequest*>(&subrequest);
DynamicSubRequest* sreq = down_cast<DynamicSubRequest*>(&subrequest);
StaticSubRequest& core = sreq->get_core();
core.set_resource_key(resource_key);
core.set_length(duration);

159
src/backend/sgpemv2/templates/down_cast.tcc Normal file
View File

@ -0,0 +1,159 @@
// sgpemv2/templates/down_cast.tcc - Copyright 2005, 2006, University
// of Padova, dept. of Pure and Applied
// Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef DOWN_CAST_TCC
#define DOWN_CAST_TCC 1
#include <functional>
#ifndef NDEBUG
#include <sys/types.h>
#include <iostream>
#include <signal.h>
#include <unistd.h>
#endif
namespace sgpem
{
/** \brief A debug functor that wraps C++ dynamic_cast
*
* Since we may want to debug exceptions easily before
* the stack becomes unwinded, this functor wraps
* the normal C++ dynamic_cast<> for references and:
*
* - if the macro NDEBUG isn't defined, and the
* dynamic_cast<> throws a std::bad_cast exception,
* suspend the process so that the debugger can
* immediately get a backtrace;
* - else, use a static_cast. This is meant for
* release code that has been \strong extensively
* tested.
*
* This template comes in two partial specializations:
* one for references, and one for pointers.
*
* Note that you shouldn't use \strong always this
* template for all your downcast, but only for those
* you don't want to test their return value because
* you assume it's correct.
*/
template<typename To>
struct _down_cast
{
// Uninstantiable for normal objects.
// Partial specializations for references and pointers
// will follow.
// We use a functor, and not a normal template function,
// because in this way the parameter of operator()
// is automatically deduced by the compiler (else we
// would have to provide two template parameters), and
// we've an extra type-check that we aren't using
// normal objects as template parameters, but
// just pointers or references.
};
// --------------------------------------
// Specialization for references:
template<typename To>
struct _down_cast<To&>
{
template<typename From>
inline To& operator()(From& obj) const
{
#ifndef NDEBUG
try
{
return dynamic_cast<To&>(obj);
}
catch(const std::bad_cast& e)
{
pid_t me = getpid();
std::clog << "DEBUG: st8ad_cast exception. "
<< "Guru Meditation #81310005.48454C50." << std::endl
<< " ** " << e.what() << std::endl
<< "Process [" << me << "] stopped." << std::endl;
kill(me, SIGSTOP);
throw;
}
#else
return static_cast<To&>(obj);
#endif
}
};
// --------------------------------------
// Specialization for pointers:
template<typename To>
struct _down_cast<To*>
{
template<typename From>
inline To* operator()(From* obj) const
{
#ifndef NDEBUG
To* check_ptr = dynamic_cast<To*>(obj);
if(check_ptr == NULL)
{
pid_t me = getpid();
std::clog << "DEBUG: dynamic_cast<> returned null pointer. "
<< "Guru Meditation #81310005.48454C50." << std::endl
<< "Process [" << me << "] stopped." << std::endl;
kill(me, SIGSTOP);
throw;
}
return check_ptr;
#else
return dynamic_cast<To*>(obj);
#endif
}
};
/** \brief Helper function to check a downcast for references
*
* See ::_down_cast for a more extensive documentation. This
* is just a wrapper to provide a more natural interface to
* the user
*/
template<typename To, typename From>
inline To down_cast(From& obj)
{
return _down_cast<To>()(obj);
}
/** \brief Helper function to check a downcast for pointers
*
* See ::_down_cast for a more extensive documentation. This
* is just a wrapper to provide a more natural interface to
* the user
*/
template<typename To, typename From>
inline To down_cast(From* const obj)
{
return _down_cast<To>()(obj);
}
} //~ namespace sgpem
#endif //~ DOWN_CAST_TCC