object.cc revision 13295:e71ae162b863
1/* 2 * Copyright 2018 Google, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer; 8 * redistributions in binary form must reproduce the above copyright 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution; 11 * neither the name of the copyright holders nor the names of its 12 * contributors may be used to endorse or promote products derived from 13 * this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * Authors: Gabe Black 28 */ 29 30#include "systemc/core/object.hh" 31 32#include <algorithm> 33#include <stack> 34 35#include "base/logging.hh" 36#include "systemc/core/event.hh" 37#include "systemc/core/module.hh" 38#include "systemc/core/scheduler.hh" 39#include "systemc/ext/core/sc_module.hh" 40 41namespace sc_gem5 42{ 43 44namespace 45{ 46 47ObjectsIt 48findObjectIn(Objects &objects, const std::string &name) 49{ 50 ObjectsIt it; 51 for (it = objects.begin(); it != objects.end(); it++) 52 if (!strcmp((*it)->name(), name.c_str())) 53 break; 54 55 return it; 56} 57 58void 59addObject(Objects *objects, sc_core::sc_object *object) 60{ 61 objects->emplace(objects->end(), object); 62} 63 64void 65popObject(Objects *objects, const std::string &name) 66{ 67 ObjectsIt it = findObjectIn(*objects, name); 68 assert(it != objects->end()); 69 std::swap(objects->back(), *it); 70 objects->pop_back(); 71} 72 73bool 74nameIsUnique(Objects *objects, Events *events, const std::string &name) 75{ 76 for (auto obj: *objects) 77 if (!strcmp(obj->basename(), name.c_str())) 78 return false; 79 for (auto event: *events) 80 if (!strcmp(event->basename(), name.c_str())) 81 return false; 82 return true; 83} 84 85} // anonymous namespace 86 87Object::Object(sc_core::sc_object *_sc_obj) : Object(_sc_obj, nullptr) {} 88 89Object::Object(sc_core::sc_object *_sc_obj, const char *obj_name) : 90 _sc_obj(_sc_obj), _basename(obj_name ? obj_name : ""), parent(nullptr) 91{ 92 if (_basename == "") 93 _basename = ::sc_core::sc_gen_unique_name("object"); 94 95 parent = pickParentObj(); 96 97 Module *n = newModule(); 98 if (n) { 99 // We are a module in the process of being constructed. 100 n->finish(this); 101 } 102 103 std::string original_name = _basename; 104 _basename = sc_gem5::pickUniqueName(parent, original_name); 105 106 if (parent) 107 addObject(&parent->_gem5_object->children, _sc_obj); 108 else 109 addObject(&topLevelObjects, _sc_obj); 110 111 addObject(&allObjects, _sc_obj); 112 113 sc_core::sc_object *sc_p = parent; 114 std::string path = ""; 115 while (sc_p) { 116 path = std::string(sc_p->basename()) + std::string(".") + path; 117 sc_p = sc_p->get_parent_object(); 118 } 119 120 if (_basename != original_name) { 121 std::string message = path + original_name + 122 ". Latter declaration will be renamed to " + 123 path + _basename; 124 SC_REPORT_WARNING("(W505) object already exists", message.c_str()); 125 } 126 _name = path + _basename; 127} 128 129Object::Object(sc_core::sc_object *_sc_obj, const Object &arg) : 130 Object(_sc_obj, arg._basename.c_str()) 131{} 132 133Object & 134Object::operator = (const Object &) 135{ 136 return *this; 137} 138 139Object::~Object() 140{ 141 // Promote all children to be top level objects. 142 for (auto child: children) { 143 addObject(&topLevelObjects, child); 144 child->_gem5_object->parent = nullptr; 145 } 146 children.clear(); 147 148 for (auto event: events) 149 Event::getFromScEvent(event)->clearParent(); 150 151 if (parent) 152 popObject(&parent->_gem5_object->children, _name); 153 else 154 popObject(&topLevelObjects, _name); 155 popObject(&allObjects, _name); 156} 157 158const char * 159Object::name() const 160{ 161 return _name.c_str(); 162} 163 164const char * 165Object::basename() const 166{ 167 return _basename.c_str(); 168} 169 170void 171Object::print(std::ostream &out) const 172{ 173 out << name(); 174} 175 176void 177Object::dump(std::ostream &out) const 178{ 179 out << "name = " << name() << "\n"; 180 out << "kind = " << _sc_obj->kind() << "\n"; 181} 182 183const std::vector<sc_core::sc_object *> & 184Object::get_child_objects() const 185{ 186 return children; 187} 188 189const std::vector<sc_core::sc_event *> & 190Object::get_child_events() const 191{ 192 return events; 193} 194 195sc_core::sc_object *Object::get_parent_object() const 196{ 197 return parent; 198} 199 200bool 201Object::add_attribute(sc_core::sc_attr_base &attr) 202{ 203 return cltn.push_back(&attr); 204} 205 206sc_core::sc_attr_base * 207Object::get_attribute(const std::string &attr) 208{ 209 return cltn[attr]; 210} 211 212sc_core::sc_attr_base * 213Object::remove_attribute(const std::string &attr) 214{ 215 return cltn.remove(attr); 216} 217 218void 219Object::remove_all_attributes() 220{ 221 cltn.remove_all(); 222} 223 224int 225Object::num_attributes() const 226{ 227 return cltn.size(); 228} 229 230sc_core::sc_attr_cltn & 231Object::attr_cltn() 232{ 233 return cltn; 234} 235 236const sc_core::sc_attr_cltn & 237Object::attr_cltn() const 238{ 239 return cltn; 240} 241 242sc_core::sc_simcontext * 243Object::simcontext() const 244{ 245 warn("%s not implemented.\n", __PRETTY_FUNCTION__); 246 return nullptr; 247} 248 249EventsIt 250Object::addChildEvent(sc_core::sc_event *e) 251{ 252 return events.emplace(events.end(), e); 253} 254 255void 256Object::delChildEvent(sc_core::sc_event *e) 257{ 258 EventsIt it = std::find(events.begin(), events.end(), e); 259 assert(it != events.end()); 260 std::swap(*it, events.back()); 261 events.pop_back(); 262} 263 264std::string 265Object::pickUniqueName(std::string base) 266{ 267 std::string seed = base; 268 while (!nameIsUnique(&children, &events, base)) 269 base = ::sc_core::sc_gen_unique_name(seed.c_str()); 270 271 return base; 272} 273 274std::string 275pickUniqueName(::sc_core::sc_object *parent, std::string base) 276{ 277 if (parent) 278 return Object::getFromScObject(parent)->pickUniqueName(base); 279 280 std::string seed = base; 281 while (!nameIsUnique(&topLevelObjects, &topLevelEvents, base)) 282 base = ::sc_core::sc_gen_unique_name(seed.c_str()); 283 284 return base; 285} 286 287 288Objects topLevelObjects; 289Objects allObjects; 290 291const std::vector<sc_core::sc_object *> & 292getTopLevelScObjects() 293{ 294 return topLevelObjects; 295} 296 297sc_core::sc_object * 298findObject(const char *name, const Objects &objects) 299{ 300 ObjectsIt it = findObjectIn(allObjects, name); 301 return it == allObjects.end() ? nullptr : *it; 302} 303 304namespace 305{ 306 307std::stack<sc_core::sc_object *> objParentStack; 308 309} // anonymous namespace 310 311sc_core::sc_object * 312pickParentObj() 313{ 314 if (!objParentStack.empty()) 315 return objParentStack.top(); 316 317 Process *p = scheduler.current(); 318 if (p) 319 return p; 320 321 return nullptr; 322} 323 324void pushParentObj(sc_core::sc_object *obj) { objParentStack.push(obj); } 325void popParentObj() { objParentStack.pop(); } 326 327} // namespace sc_gem5 328