derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

systemc: Implement much of events, event lists and event exprs.

Browse Source 
Three things aren't yet implemented, waking up processes which are
sensitive to the event, triggering of events, and garbage collecting
list objects which came from expression objects.

The garbage collection aspect is problematic since there doesn't seem
to be a correct way to implement it given the constraints in the spec,
including the way that's implemented by Accellera. It's something that
will need to be dealt with at some point, but in the interest of
forward progress it's being ignored for now.

Change-Id: Ic4e3c219ff482729f1f1302ab10181a798d48041
Reviewed-on: https://gem5-review.googlesource.com/11711
Reviewed-by: Gabe Black <gabeblack@google.com>
Maintainer: Gabe Black <gabeblack@google.com>
This commit is contained in:
Gabe Black
2018-07-11 20:00:50 -07:00
parent 7088d69ab5
commit 7b8c8bcaa5
7 changed files with 576 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/systemc/core/SConscript
View File

@@ -31,6 +31,7 @@ if env['USE_SYSTEMC']:
SimObject('SystemC.py')
Source('channel.cc')
Source('event.cc')
Source('kernel.cc')
Source('module.cc')
Source('object.cc')

145
src/systemc/core/event.cc Normal file
View File

@@ -0,0 +1,145 @@
/*
* Copyright 2018 Google, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Gabe Black
*/
#include "systemc/core/event.hh"
#include <cstring>
#include <utility>
#include "systemc/core/module.hh"
#include "systemc/core/scheduler.hh"
namespace sc_gem5
{
Event::Event(sc_core::sc_event *_sc_event) : Event(_sc_event, "") {}
Event::Event(sc_core::sc_event *_sc_event, const char *_basename) :
_sc_event(_sc_event), _basename(_basename)
{
Module *p = currentModule();
if (p)
parent = p->obj()->sc_obj();
else if (scheduler.current())
parent = scheduler.current();
if (parent) {
Object *obj = Object::getFromScObject(parent);
parentIt = obj->addChildEvent(_sc_event);
} else {
parentIt = topLevelEvents.emplace(topLevelEvents.end(), _sc_event);
}
if (parent)
_name = std::string(parent->name()) + "." + _basename;
else
_name = _basename;
allEvents.emplace(allEvents.end(), _sc_event);
// Determine if we're in the hierarchy (created once initialization starts
// means no).
}
Event::~Event()
{
if (parent) {
Object *obj = Object::getFromScObject(parent);
obj->delChildEvent(parentIt);
} else {
std::swap(*parentIt, topLevelEvents.back());
topLevelEvents.pop_back();
}
EventsIt it = findEvent(_name);
std::swap(*it, allEvents.back());
allEvents.pop_back();
}
const std::string &
Event::name() const
{
return _name;
}
const std::string &
Event::basename() const
{
return _basename;
}
bool
Event::inHierarchy() const
{
return _name.length() != 0;
}
sc_core::sc_object *
Event::getParentObject() const
{
return parent;
}
void
Event::notify()
{
}
void
Event::notify(const sc_core::sc_time &t)
{
}
void
Event::cancel()
{
}
bool
Event::triggered() const
{
return false;
}
Events topLevelEvents;
Events allEvents;
EventsIt
findEvent(const std::string &name)
{
EventsIt it;
for (it = allEvents.begin(); it != allEvents.end(); it++)
if (!strcmp((*it)->name(), name.c_str()))
break;
return it;
}
} // namespace sc_gem5

109
src/systemc/core/event.hh Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2018 Google, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Gabe Black
*/
#ifndef __SYSTEMC_CORE_EVENT_HH__
#define __SYSTEMC_CORE_EVENT_HH__
#include <string>
#include <vector>
#include "systemc/core/list.hh"
#include "systemc/core/object.hh"
#include "systemc/ext/core/sc_prim.hh"
#include "systemc/ext/core/sc_time.hh"
namespace sc_core
{
class sc_event;
} // namespace sc_core
namespace sc_gem5
{
typedef std::vector<sc_core::sc_event *> Events;
class Event
{
public:
Event(sc_core::sc_event *_sc_event);
Event(sc_core::sc_event *_sc_event, const char *_basename);
~Event();
sc_core::sc_event *sc_event() { return _sc_event; }
const std::string &name() const;
const std::string &basename() const;
bool inHierarchy() const;
sc_core::sc_object *getParentObject() const;
void notify();
void notify(const sc_core::sc_time &t);
void
notify(double d, sc_core::sc_time_unit &u)
{
notify(sc_core::sc_time(d, u));
}
void cancel();
bool triggered() const;
static Event *
getFromScEvent(sc_core::sc_event *e)
{
return e->_gem5_event;
}
static const Event *
getFromScEvent(const sc_core::sc_event *e)
{
return e->_gem5_event;
}
private:
sc_core::sc_event *_sc_event;
std::string _basename;
std::string _name;
bool _inHierarchy;
sc_core::sc_object *parent;
EventsIt parentIt;
};
extern Events topLevelEvents;
extern Events allEvents;
EventsIt findEvent(const std::string &name);
} // namespace sc_gem5
#endif //__SYSTEMC_CORE_EVENT_HH__

33
src/systemc/core/object.cc
View File

@@ -67,10 +67,10 @@ popObject(Objects *objects, const std::string &name)
} // anonymous namespace
Object::Object(sc_core::sc_object *sc_obj) : Object(sc_obj, "object") {}
Object::Object(sc_core::sc_object *_sc_obj) : Object(_sc_obj, "object") {}
Object::Object(sc_core::sc_object *sc_obj, const char *obj_name) :
sc_obj(sc_obj), _basename(obj_name), parent(nullptr)
Object::Object(sc_core::sc_object *_sc_obj, const char *obj_name) :
_sc_obj(_sc_obj), _basename(obj_name), parent(nullptr)
{
if (_basename == "")
_basename = "object";
@@ -86,17 +86,17 @@ Object::Object(sc_core::sc_object *sc_obj, const char *obj_name) :
if (p) {
// We're "within" a parent module, ie we're being created while its
// constructor is running.
parent = p->obj()->sc_obj;
addObject(&parent->_gem5_object->children, sc_obj);
parent = p->obj()->_sc_obj;
addObject(&parent->_gem5_object->children, _sc_obj);
} else if (scheduler.current()) {
// Our parent is the currently running process.
parent = scheduler.current();
} else {
// We're a top level object.
addObject(&topLevelObjects, sc_obj);
addObject(&topLevelObjects, _sc_obj);
}
addObject(&allObjects, sc_obj);
addObject(&allObjects, _sc_obj);
_name = _basename;
sc_core::sc_object *sc_p = parent;
@@ -106,8 +106,8 @@ Object::Object(sc_core::sc_object *sc_obj, const char *obj_name) :
}
}
Object::Object(sc_core::sc_object *sc_obj, const Object &arg) :
Object(sc_obj, arg._basename.c_str())
Object::Object(sc_core::sc_object *_sc_obj, const Object &arg) :
Object(_sc_obj, arg._basename.c_str())
{}
Object &
@@ -149,7 +149,7 @@ void
Object::dump(std::ostream &out) const
{
out << "name = " << name() << "\n";
out << "kind = " << sc_obj->kind() << "\n";
out << "kind = " << _sc_obj->kind() << "\n";
}
const std::vector<sc_core::sc_object *> &
@@ -218,6 +218,19 @@ Object::simcontext() const
return nullptr;
}
EventsIt
Object::addChildEvent(sc_core::sc_event *e)
{
return events.emplace(events.end(), e);
}
void
Object::delChildEvent(EventsIt it)
{
std::swap(*it, events.back());
events.pop_back();
}
Objects topLevelObjects;
Objects allObjects;

20
src/systemc/core/object.hh
View File

@@ -44,13 +44,14 @@ class Object;
typedef std::vector<sc_core::sc_object *> Objects;
typedef std::vector<sc_core::sc_event *> Events;
typedef Objects::iterator ObjectsIt;
typedef Events::iterator EventsIt;
class Object
{
public:
Object(sc_core::sc_object *sc_obj);
Object(sc_core::sc_object *sc_obj, const char *);
Object(sc_core::sc_object *sc_obj, const Object &);
Object(sc_core::sc_object *_sc_obj);
Object(sc_core::sc_object *_sc_obj, const char *);
Object(sc_core::sc_object *_sc_obj, const Object &);
Object &operator = (const Object &);
virtual ~Object();
@@ -78,8 +79,19 @@ class Object
sc_core::sc_simcontext *simcontext() const;
static Object *
getFromScObject(sc_core::sc_object *sc_obj)
{
return sc_obj->_gem5_object;
}
sc_core::sc_object *sc_obj() { return _sc_obj; }
EventsIt addChildEvent(sc_core::sc_event *e);
void delChildEvent(EventsIt it);
private:
sc_core::sc_object *sc_obj;
sc_core::sc_object *_sc_obj;
std::string _basename;
std::string _name;

376
src/systemc/core/sc_event.cc
View File

@@ -28,314 +28,378 @@
*/
#include "base/logging.hh"
#include "systemc/core/event.hh"
#include "systemc/ext/core/sc_event.hh"
namespace sc_core
{
/*
* sc_event_finder
*/
void
sc_event_finder::warn_unimpl(const char *func) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event_and_list::sc_event_and_list()
/*
* sc_event_and_list
*/
sc_event_and_list::sc_event_and_list() : autoDelete(false), busy(0) {}
sc_event_and_list::sc_event_and_list(const sc_event_and_list &eal) :
events(eal.events), autoDelete(false), busy(0)
{}
sc_event_and_list::sc_event_and_list(const sc_event &e) : sc_event_and_list()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(e);
}
sc_event_and_list::sc_event_and_list(const sc_event_and_list &)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event_and_list::sc_event_and_list(bool auto_delete) :
autoDelete(auto_delete), busy(0)
{}
sc_event_and_list::sc_event_and_list(const sc_event &)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event_and_list::~sc_event_and_list() {}
sc_event_and_list &
sc_event_and_list::operator = (const sc_event_and_list &)
sc_event_and_list::operator = (const sc_event_and_list &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events = eal.events;
return *this;
}
int
sc_event_and_list::size() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return 0;
return events.size();
}
void
sc_event_and_list::swap(sc_event_and_list &)
sc_event_and_list::swap(sc_event_and_list &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events.swap(eal.events);
}
sc_event_and_list &
sc_event_and_list::operator &= (const sc_event &)
sc_event_and_list::operator &= (const sc_event &e)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(e);
return *this;
}
sc_event_and_list &
sc_event_and_list::operator &= (const sc_event_and_list &)
sc_event_and_list::operator &= (const sc_event_and_list &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(eal);
return *this;
}
sc_event_and_expr
sc_event_and_list::operator & (const sc_event &) const
sc_event_and_list::operator & (const sc_event &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_and_expr();
sc_event_and_expr expr;
expr.insert(*this);
expr.insert(e);
return expr;
}
sc_event_and_expr
sc_event_and_list::operator & (const sc_event_and_list &)
sc_event_and_list::operator & (const sc_event_and_list &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_and_expr();
sc_event_and_expr expr;
expr.insert(*this);
expr.insert(eal);
return expr;
}
sc_event_or_list::sc_event_or_list()
void
sc_event_and_list::insert(sc_event const &e)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events.insert(&e);
}
sc_event_or_list::sc_event_or_list(const sc_event_or_list &)
void
sc_event_and_list::insert(sc_event_and_list const &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events.insert(eal.events.begin(), eal.events.end());
}
sc_event_or_list::sc_event_or_list(const sc_event &)
/*
* sc_event_or_list
*/
sc_event_or_list::sc_event_or_list() : autoDelete(false), busy(0) {}
sc_event_or_list::sc_event_or_list(const sc_event_or_list &eol) :
events(eol.events), autoDelete(false), busy(0)
{}
sc_event_or_list::sc_event_or_list(const sc_event &e) : sc_event_or_list()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(e);
}
sc_event_or_list&
sc_event_or_list::operator = (const sc_event_or_list &)
sc_event_or_list::sc_event_or_list(bool auto_delete) :
autoDelete(auto_delete), busy(0)
{}
sc_event_or_list &
sc_event_or_list::operator = (const sc_event_or_list &eol)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events = eol.events;
return *this;
}
sc_event_or_list::~sc_event_or_list()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event_or_list::~sc_event_or_list() {}
int
sc_event_or_list::size() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return 0;
return events.size();
}
void
sc_event_or_list::swap(sc_event_or_list &)
sc_event_or_list::swap(sc_event_or_list &eol)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
events.swap(eol.events);
}
sc_event_or_list &
sc_event_or_list::operator |= (const sc_event &)
sc_event_or_list::operator |= (const sc_event &e)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(e);
return *this;
}
sc_event_or_list &
sc_event_or_list::operator |= (const sc_event_or_list &)
sc_event_or_list::operator |= (const sc_event_or_list &eol)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
insert(eol);
return *this;
}
sc_event_or_expr
sc_event_or_list::operator | (const sc_event &) const
sc_event_or_list::operator | (const sc_event &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_or_expr();
sc_event_or_expr expr;
expr.insert(*this);
expr.insert(e);
return expr;
}
sc_event_or_expr
sc_event_or_list::operator | (const sc_event_or_list &) const
sc_event_or_list::operator | (const sc_event_or_list &eol) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_or_expr();
sc_event_or_expr expr;
expr.insert(*this);
expr.insert(eol);
return expr;
}
void
sc_event_or_list::insert(sc_event const &e)
{
events.insert(&e);
}
void
sc_event_or_list::insert(sc_event_or_list const &eol)
{
events.insert(eol.events.begin(), eol.events.end());
}
/*
* sc_event_and_expr
*/
// Move semantics
sc_event_and_expr::sc_event_and_expr(sc_event_and_expr const &e) :
list(e.list)
{
e.list = nullptr;
}
sc_event_and_expr::operator const sc_event_and_list &() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return *(const sc_event_and_list *)nullptr;
sc_event_and_list *temp = list;
list = nullptr;
return *temp;
}
sc_event_and_expr
operator & (sc_event_and_expr expr, sc_event const &)
void
sc_event_and_expr::insert(sc_event const &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
assert(list);
list->insert(e);
}
void
sc_event_and_expr::insert(sc_event_and_list const &eal) const
{
assert(list);
list->insert(eal);
}
sc_event_and_expr::~sc_event_and_expr() { delete list; }
sc_event_and_expr::sc_event_and_expr() : list(new sc_event_and_list(true)) {}
sc_event_and_expr
operator & (sc_event_and_expr expr, sc_event const &e)
{
expr.insert(e);
return expr;
}
sc_event_and_expr
operator & (sc_event_and_expr expr, sc_event_and_list const &)
operator & (sc_event_and_expr expr, sc_event_and_list const &eal)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
expr.insert(eal);
return expr;
}
/*
* sc_event_or_expr
*/
// Move semantics
sc_event_or_expr::sc_event_or_expr(sc_event_or_expr const &e) :
list(e.list)
{
e.list = nullptr;
}
sc_event_or_expr::operator const sc_event_or_list &() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return *(const sc_event_or_list *)nullptr;
sc_event_or_list *temp = list;
list = NULL;
return *temp;
}
sc_event_or_expr
operator | (sc_event_or_expr expr, sc_event const &)
void
sc_event_or_expr::insert(sc_event const &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
assert(list);
list->insert(e);
}
void
sc_event_or_expr::insert(sc_event_or_list const &eol) const
{
assert(list);
list->insert(eol);
}
sc_event_or_expr::~sc_event_or_expr() { delete list; }
sc_event_or_expr::sc_event_or_expr() : list(new sc_event_or_list(true)) {}
sc_event_or_expr
operator | (sc_event_or_expr expr, sc_event const &e)
{
expr.insert(e);
return expr;
}
sc_event_or_expr
operator | (sc_event_or_expr expr, sc_event_or_list const &)
operator | (sc_event_or_expr expr, sc_event_or_list const &eol)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
expr.insert(eol);
return expr;
}
sc_event::sc_event()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event::sc_event(const char *)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
/*
* sc_event
*/
sc_event::~sc_event()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
sc_event::sc_event() : _gem5_event(new ::sc_gem5::Event(this)) {}
const char *
sc_event::name() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return "";
}
sc_event::sc_event(const char *_name) :
_gem5_event(new ::sc_gem5::Event(this, _name))
{}
sc_event::~sc_event() { delete _gem5_event; }
const char *sc_event::name() const { return _gem5_event->name().c_str(); }
const char *
sc_event::basename() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return "";
}
bool
sc_event::in_hierarchy() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return false;
return _gem5_event->basename().c_str();
}
bool sc_event::in_hierarchy() const { return _gem5_event->inHierarchy(); }
sc_object *
sc_event::get_parent_object() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return (sc_object *)nullptr;
return _gem5_event->getParentObject();
}
void
sc_event::notify()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
void sc_event::notify() { _gem5_event->notify(); }
void sc_event::notify(const sc_time &t) { _gem5_event->notify(t); }
void sc_event::notify(double d, sc_time_unit u) { _gem5_event->notify(d, u); }
void sc_event::cancel() { _gem5_event->cancel(); }
bool sc_event::triggered() const { return _gem5_event->triggered(); }
void sc_event::notify_delayed() { _gem5_event->notify(SC_ZERO_TIME); }
void sc_event::notify_delayed(const sc_time &t) { _gem5_event->notify(t); }
void
sc_event::notify(const sc_time &)
sc_event_and_expr
sc_event::operator & (const sc_event &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
void
sc_event::notify(double, sc_time_unit)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
void
sc_event::cancel()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
bool
sc_event::triggered() const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return false;
}
void
sc_event::notify_delayed()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
}
void
sc_event::notify_delayed(const sc_time &)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
sc_event_and_expr expr;
expr.insert(*this);
expr.insert(e);
return expr;
}
sc_event_and_expr
sc_event::operator & (const sc_event &) const
sc_event::operator & (const sc_event_and_list &eal) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_and_expr();
}
sc_event_and_expr
sc_event::operator & (const sc_event_and_list &) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_and_expr();
sc_event_and_expr expr;
expr.insert(*this);
expr.insert(eal);
return expr;
}
sc_event_or_expr
sc_event::operator | (const sc_event &) const
sc_event::operator | (const sc_event &e) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_or_expr();
sc_event_or_expr expr;
expr.insert(*this);
expr.insert(e);
return expr;
}
sc_event_or_expr
sc_event::operator | (const sc_event_or_list &) const
sc_event::operator | (const sc_event_or_list &eol) const
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return sc_event_or_expr();
sc_event_or_expr expr;
expr.insert(*this);
expr.insert(eol);
return expr;
}
const std::vector<sc_event *> &
sc_get_top_level_events()
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return *(const std::vector<sc_event *> *)nullptr;
return ::sc_gem5::topLevelEvents;
}
sc_event *
sc_find_event(const char *)
sc_find_event(const char *name)
{
warn("%s not implemented.\n", __PRETTY_FUNCTION__);
return (sc_event *)nullptr;
std::string str(name);
::sc_gem5::EventsIt it = ::sc_gem5::findEvent(str);
return it == ::sc_gem5::allEvents.end() ? nullptr : *it;
}
} // namespace sc_core

62
src/systemc/ext/core/sc_event.hh
View File

@@ -30,10 +30,18 @@
#ifndef __SYSTEMC_EXT_CORE_SC_EVENT_HH__
#define __SYSTEMC_EXT_CORE_SC_EVENT_HH__
#include <set>
#include <vector>
#include "sc_time.hh"
namespace sc_gem5
{
class Event;
}
namespace sc_core
{
@@ -79,6 +87,7 @@ class sc_event_and_list
sc_event_and_list(const sc_event_and_list &);
sc_event_and_list(const sc_event &);
sc_event_and_list &operator = (const sc_event_and_list &);
~sc_event_and_list();
int size() const;
void swap(sc_event_and_list &);
@@ -88,6 +97,18 @@ class sc_event_and_list
sc_event_and_expr operator & (const sc_event &) const;
sc_event_and_expr operator & (const sc_event_and_list &);
private:
friend class sc_event_and_expr;
explicit sc_event_and_list(bool auto_delete);
void insert(sc_event const &e);
void insert(sc_event_and_list const &eal);
std::set<const sc_event *> events;
bool autoDelete;
mutable unsigned busy;
};
class sc_event_or_list
@@ -107,12 +128,37 @@ class sc_event_or_list
sc_event_or_expr operator | (const sc_event &) const;
sc_event_or_expr operator | (const sc_event_or_list &) const;
private:
friend class sc_event_or_expr;
explicit sc_event_or_list(bool auto_delete);
void insert(sc_event const &e);
void insert(sc_event_or_list const &eol);
std::set<const sc_event *> events;
bool autoDelete;
mutable unsigned busy;
};
class sc_event_and_expr
{
public:
sc_event_and_expr(sc_event_and_expr const &e);
operator const sc_event_and_list &() const;
void insert(sc_event const &e) const;
void insert(sc_event_and_list const &eal) const;
~sc_event_and_expr();
private:
friend class sc_event_and_list;
friend class sc_event;
sc_event_and_expr();
mutable sc_event_and_list *list;
};
sc_event_and_expr operator & (sc_event_and_expr, sc_event const &);
@@ -121,7 +167,20 @@ sc_event_and_expr operator & (sc_event_and_expr, sc_event_and_list const &);
class sc_event_or_expr
{
public:
sc_event_or_expr(sc_event_or_expr const &e);
operator const sc_event_or_list &() const;
void insert(sc_event const &e) const;
void insert(sc_event_or_list const &eol) const;
~sc_event_or_expr();
private:
friend class sc_event_or_list;
friend class sc_event;
sc_event_or_expr();
mutable sc_event_or_list *list;
};
sc_event_or_expr operator | (sc_event_or_expr, sc_event const &);
@@ -161,6 +220,9 @@ class sc_event
// Disabled
sc_event(const sc_event &) {}
sc_event &operator = (const sc_event &) { return *this; }
friend class ::sc_gem5::Event;
::sc_gem5::Event *_gem5_event;
};
const std::vector<sc_event *> &sc_get_top_level_events();