gem5  v21.1.0.2
cxx_manager.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 ARM Limited
3  * All rights reserved
4  *
5  * The license below extends only to copyright in the software and shall
6  * not be construed as granting a license to any other intellectual
7  * property including but not limited to intellectual property relating
8  * to a hardware implementation of the functionality of the software
9  * licensed hereunder. You may use the software subject to the license
10  * terms below provided that you ensure that this notice is replicated
11  * unmodified and in its entirety in all distributions of the software,
12  * modified or unmodified, in source code or in binary form.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions are
16  * met: redistributions of source code must retain the above copyright
17  * notice, this list of conditions and the following disclaimer;
18  * redistributions in binary form must reproduce the above copyright
19  * notice, this list of conditions and the following disclaimer in the
20  * documentation and/or other materials provided with the distribution;
21  * neither the name of the copyright holders nor the names of its
22  * contributors may be used to endorse or promote products derived from
23  * this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
37 
38 #include "sim/cxx_manager.hh"
39 
40 #include <cstdlib>
41 #include <sstream>
42 
43 #include "base/str.hh"
44 #include "base/trace.hh"
45 #include "debug/CxxConfig.hh"
46 #include "sim/serialize.hh"
47 #include "sim/sim_object.hh"
48 
49 namespace gem5
50 {
51 
53  configFile(configFile_), flags(configFile_.getFlags()),
54  simObjectResolver(*this)
55 {
56 }
57 
59 CxxConfigManager::findObjectType(const std::string &object_name,
60  std::string &object_type)
61 {
62  if (!configFile.objectExists(object_name))
63  throw Exception(object_name, "Can't find sim object");
64 
65  if (!configFile.getParam(object_name, "type", object_type))
66  throw Exception(object_name, "Sim object has no 'type' field");
67 
68  if (cxx_config_directory.find(object_type) ==
70  {
71  throw Exception(object_name, csprintf(
72  "No sim object type %s is available", object_type));
73  }
74 
75  const CxxConfigDirectoryEntry *entry = cxx_config_directory[object_type];
76 
77  return *entry;
78 }
79 
80 std::string
81 CxxConfigManager::rename(const std::string &from_name)
82 {
83  for (auto i = renamings.begin(); i != renamings.end(); ++ i) {
84  const Renaming &renaming = *i;
85 
86  if (from_name.find(renaming.fromPrefix) == 0) {
87  return renaming.toPrefix +
88  from_name.substr(renaming.fromPrefix.length());
89  }
90  }
91 
92  return from_name;
93 }
94 
95 std::string
96 CxxConfigManager::unRename(const std::string &to_name)
97 {
98  for (auto i = renamings.begin(); i != renamings.end(); ++ i) {
99  const Renaming &renaming = *i;
100 
101  if (to_name.find(renaming.toPrefix) == 0) {
102  return renaming.fromPrefix +
103  to_name.substr(renaming.toPrefix.length());
104  }
105  }
106 
107  return to_name;
108 }
109 
110 static
111 std::string formatParamList(const std::vector<std::string> &param_values)
112 {
113  std::ostringstream params;
114 
115  auto i = param_values.begin();
116  auto end_i = param_values.end();
117 
118  params << '[';
119  while (i != end_i) {
120  params << (*i);
121  ++i;
122 
123  if (i != end_i)
124  params << ", ";
125  }
126  params << ']';
127 
128  return params.str();
129 }
130 
131 SimObject *
132 CxxConfigManager::findObject(const std::string &object_name,
133  bool visit_children)
134 {
135  std::string instance_name = rename(object_name);
136 
137  if (object_name == "Null")
138  return NULL;
139 
140  /* Already constructed */
141  if (objectsByName.find(instance_name) != objectsByName.end())
142  return objectsByName[instance_name];
143 
144  if (inVisit.find(instance_name) != inVisit.end())
145  throw Exception(instance_name, "Cycle in configuration");
146 
147  std::string object_type;
148  const CxxConfigDirectoryEntry &entry =
149  findObjectType(object_name, object_type);
150 
151  SimObject *object = NULL;
152 
153  CxxConfigParams *object_params = findObjectParams(object_name);
154 
155  try {
156  DPRINTF(CxxConfig, "Configuring sim object references for: %s"
157  " (%s from object %s)\n", instance_name, object_type,
158  object_name);
159 
160  /* Remember the path back to the top of the recursion to detect
161  * cycles */
162  inVisit.insert(instance_name);
163 
164  /* Resolve pointed-to SimObjects by recursing into them */
165  for (auto i = entry.parameters.begin();
166  i != entry.parameters.end(); ++i)
167  {
168  const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
169 
170  if (param->isSimObject) {
171  if (param->isVector) {
172  std::vector<std::string> sub_object_names;
173 
174  if (!configFile.getParamVector(object_name, param->name,
175  sub_object_names))
176  {
177  throw Exception(object_name, csprintf(
178  "Element not found: %s", param->name));
179  }
180 
181  std::vector<SimObject *> sub_objects;
182 
183  for (auto n = sub_object_names.begin();
184  n != sub_object_names.end(); ++n)
185  {
186  SimObject *sub_object = findObject(*n,
187  visit_children);
188 
189  if (sub_object)
190  sub_objects.push_back(sub_object);
191  }
192 
193  if (!object_params->setSimObjectVector(param->name,
194  sub_objects))
195  {
196  throw Exception(object_name, csprintf(
197  "Can't assign sim object element %s from \"%s\"",
198  param->name, formatParamList(sub_object_names)));
199  }
200 
201  DPRINTF(CxxConfig, "Setting sim object(s): %s.%s=%s\n",
202  object_name, param->name,
203  formatParamList(sub_object_names));
204  } else {
205  std::string sub_object_name;
206 
207  if (!configFile.getParam(object_name, param->name,
208  sub_object_name))
209  {
210  throw Exception(object_name, csprintf(
211  "Element not found: %s", param->name));
212  }
213 
214  SimObject *sub_object = findObject(sub_object_name,
215  visit_children);
216 
217  if (sub_object) {
218  if (!object_params->setSimObject(param->name,
219  sub_object))
220  {
221  throw Exception(object_name, csprintf(
222  "Can't assign sim object element %s from"
223  " \"%s\"", param->name, sub_object_name));
224  }
225  }
226 
227  DPRINTF(CxxConfig, "Setting sim object(s):"
228  " %s.%s=%s\n", object_name, param->name,
229  sub_object_name);
230  }
231  }
232  }
233 
234  DPRINTF(CxxConfig, "Creating SimObject: %s\n", instance_name);
235  object = object_params->simObjectCreate();
236 
237  if (!object) {
238  throw Exception(object_name, csprintf("Couldn't create object of"
239  " type: %s", object_type));
240  }
241 
242  objectsByName[instance_name] = object;
243  objectParamsByName[instance_name] = object_params;
244 
245  if (visit_children) {
246  std::vector<std::string> children;
247  configFile.getObjectChildren(object_name, children, true);
248 
249  /* Visit all your children */
250  for (auto i = children.begin(); i != children.end(); ++i)
251  findObject(*i, visit_children);
252  }
253  } catch (Exception &) {
254  delete object_params;
255  throw;
256  }
257 
258  /* Mark that we've exited object
259  * construction and so 'find'ing this object again won't be a
260  * configuration loop */
261  inVisit.erase(object_name);
262  return object;
263 }
264 
266 CxxConfigManager::findObjectParams(const std::string &object_name)
267 {
268  std::string instance_name = rename(object_name);
269 
270  /* Already constructed */
271  if (objectParamsByName.find(instance_name) != objectParamsByName.end())
272  return objectParamsByName[instance_name];
273 
274  std::string object_type;
275  const CxxConfigDirectoryEntry &entry =
276  findObjectType(object_name, object_type);
277 
278  DPRINTF(CxxConfig, "Configuring parameters of object: %s (%s)\n",
279  instance_name, object_type);
280 
281  CxxConfigParams *object_params = entry.makeParamsObject();
282 
283  try {
284  /* Fill in the implicit parameters that don't necessarily
285  * appear in config files */
286  object_params->setName(instance_name);
287 
288  /* Fill in parameters */
289  for (auto i = entry.parameters.begin();
290  i != entry.parameters.end(); ++i)
291  {
292  const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
293 
294  if (!param->isSimObject) {
295  /* Only handle non-SimObject parameters here (see below) */
296 
297  if (param->isVector) {
298  std::vector<std::string> param_values;
299 
300  if (!configFile.getParamVector(object_name, param->name,
301  param_values))
302  {
303  throw Exception(object_name, csprintf(
304  "Element not found for parameter: %s",
305  param->name));
306  }
307 
308  if (!object_params->setParamVector(param->name,
309  param_values, flags))
310  {
311  throw Exception(instance_name, csprintf(
312  "Bad parameter value: .%s=X=\"%s\"",
313  param->name, formatParamList(param_values)));
314  }
315 
316  DPRINTF(CxxConfig, "Setting parameter"
317  " %s.%s=%s\n", instance_name, param->name,
318  formatParamList(param_values));
319  } else {
320  std::string param_value;
321 
322  if (!configFile.getParam(object_name, param->name,
323  param_value))
324  {
325  throw Exception(object_name, csprintf(
326  "Element not found for parameter: %s",
327  param->name));
328  }
329 
330  if (!object_params->setParam(param->name, param_value,
331  flags))
332  {
333  throw Exception(instance_name, csprintf(
334  "Bad parameter value: .%s=X=\"%s\"",
335  param->name, param_value));
336  }
337 
338  DPRINTF(CxxConfig, "Setting parameter %s.%s=%s\n",
339  instance_name, param->name, param_value);
340  }
341  }
342  }
343 
344  /* Find the number of ports that will need binding and set the
345  * appropriate port_..._connection_count parameters */
346  for (auto i = entry.ports.begin(); i != entry.ports.end(); ++i) {
347  const CxxConfigDirectoryEntry::PortDesc *port = (*i).second;
349 
350  if (!configFile.getPortPeers(object_name, port->name, peers)) {
351  DPRINTF(CxxConfig, "Port not found: %s.%s,"
352  " assuming there are no connections\n",
353  instance_name, port->name);
354  }
355 
356  unsigned int peer_count = peers.size();
357 
358  /* It would be more efficient to split the peer list and
359  * save the values for peer binding later but that would
360  * require another annoying intermediate structure to
361  * hold for little performance increase */
362 
363  if (!object_params->setPortConnectionCount(port->name,
364  peer_count))
365  {
366  throw Exception(instance_name, csprintf(
367  "Unconnected port: %s", port->name));
368  }
369 
370  DPRINTF(CxxConfig, "Setting port connection count"
371  " for: %s.%s to %d\n",
372  instance_name, port->name, peer_count);
373  }
374 
375  /* Set pointed-to SimObjects to NULL */
376  for (auto i = entry.parameters.begin();
377  i != entry.parameters.end(); ++i)
378  {
379  const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
380 
381  if (param->isSimObject) {
382  bool ret;
383 
384  DPRINTF(CxxConfig, "Nulling sim object reference: %s.%s\n",
385  instance_name, param->name);
386 
387  if (param->isVector) {
388  /* Clear the reference list. */
390  ret = object_params->setSimObjectVector(param->name,
391  empty);
392  } else {
393  ret = object_params->setSimObject(param->name, NULL);
394  }
395 
396  if (!ret) {
397  throw Exception(instance_name, csprintf(
398  "Error nulling sim object reference(s): %s",
399  param->name));
400  }
401  }
402  }
403  } catch (Exception &) {
404  delete object_params;
405  throw;
406  }
407 
408  objectParamsByName[instance_name] = object_params;
409 
410  return object_params;
411 }
412 
413 void
415 {
416  std::vector<std::string> objects;
417  configFile.getAllObjectNames(objects);
418 
419  /* Set the traversal order for further iterators */
420  objectsInOrder.clear();
421  findTraversalOrder("root");
422 }
423 
424 void
425 CxxConfigManager::findTraversalOrder(const std::string &object_name)
426 {
427  SimObject *object = findObject(object_name);
428 
429  if (object) {
430  objectsInOrder.push_back(object);
431 
432  std::vector<std::string> children;
433  configFile.getObjectChildren(object_name, children, true);
434 
435  /* Visit all your children */
436  for (auto i = children.begin(); i != children.end(); ++i)
438  }
439 }
440 
441 void
443 {
444  for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++i)
445  bindObjectPorts(*i);
446 }
447 
448 void
450  SimObject *requestor_object, const std::string &request_port_name,
451  PortID request_port_index,
452  SimObject *responder_object, const std::string &response_port_name,
453  PortID response_port_index)
454 {
455  /* FIXME, check response_port_index against connection_count
456  * defined for port, need getPortConnectionCount and a
457  * getCxxConfigDirectoryEntry for each object. */
458 
459  /* It would be nice to be able to catch the errors from these calls. */
460  Port &request_port = requestor_object->getPort(
461  request_port_name, request_port_index);
462  Port &response_port = responder_object->getPort(
463  response_port_name, response_port_index);
464 
465  if (request_port.isConnected()) {
466  throw Exception(requestor_object->name(), csprintf(
467  "Request port: %s[%d] is already connected\n", request_port_name,
468  request_port_index));
469  }
470 
471  if (response_port.isConnected()) {
472  throw Exception(responder_object->name(), csprintf(
473  "Response port: %s[%d] is already connected\n", response_port_name,
474  response_port_index));
475  }
476 
477  DPRINTF(CxxConfig, "Binding port %s.%s[%d]"
478  " to %s:%s[%d]\n",
479  requestor_object->name(), request_port_name, request_port_index,
480  responder_object->name(), response_port_name, response_port_index);
481 
482  request_port.bind(response_port);
483 }
484 
485 void
488  const std::vector<std::string> &peers)
489 {
490  unsigned int request_port_index = 0;
491 
492  for (auto peer_i = peers.begin(); peer_i != peers.end();
493  ++peer_i)
494  {
495  const std::string &peer = *peer_i;
496  std::string response_object_name;
497  std::string response_port_name;
498  unsigned int response_port_index;
499 
500  parsePort(peer, response_object_name, response_port_name,
501  response_port_index);
502 
503  std::string response_instance_name = rename(response_object_name);
504 
505  if (objectsByName.find(response_instance_name)
506  == objectsByName.end()) {
507  throw Exception(object->name(), csprintf(
508  "Can't find response port object: %s",
509  response_instance_name));
510  }
511 
512  SimObject *responder_object = objectsByName[response_instance_name];
513 
514  bindPort(object, port.name, request_port_index,
515  responder_object, response_port_name, response_port_index);
516 
517  request_port_index++;
518  }
519 }
520 
521 void
523 {
524  /* We may want to separate object->name() from the name in configuration
525  * later to allow (for example) repetition of fragments of configs */
526  const std::string &instance_name = object->name();
527 
528  std::string object_name = unRename(instance_name);
529 
530  std::string object_type;
531  const CxxConfigDirectoryEntry &entry =
532  findObjectType(object_name, object_type);
533 
534  DPRINTF(CxxConfig, "Binding ports of object: %s (%s)\n",
535  instance_name, object_type);
536 
537  for (auto i = entry.ports.begin(); i != entry.ports.end(); ++i) {
538  const CxxConfigDirectoryEntry::PortDesc *port = (*i).second;
539 
540  DPRINTF(CxxConfig, "Binding port: %s.%s\n", instance_name,
541  port->name);
542 
544  configFile.getPortPeers(object_name, port->name, peers);
545 
546  /* Only handle master ports as binding only needs to happen once
547  * for each observed pair of ports */
548  if (port->isRequestor) {
549  if (!port->isVector && peers.size() > 1) {
550  throw Exception(instance_name, csprintf(
551  "Too many connections to non-vector port %s (%d)\n",
552  port->name, peers.size()));
553  }
554 
555  bindRequestPort(object, *port, peers);
556  }
557  }
558 }
559 
560 void
561 CxxConfigManager::parsePort(const std::string &inp,
562  std::string &path, std::string &port, unsigned int &index)
563 {
564  std::size_t dot_i = inp.rfind('.');
565  std::size_t open_square_i = inp.rfind('[');
566 
567  if (dot_i == std::string::npos) {
568  DPRINTF(CxxConfig, "Bad port string: %s\n", inp);
569  path = "";
570  port = "";
571  index = 0;
572  } else {
573  path = std::string(inp, 0, dot_i);
574 
575  if (open_square_i == std::string::npos) {
576  /* Singleton port */
577  port = std::string(inp, dot_i + 1, inp.length() - dot_i);
578  index = 0;
579  } else {
580  /* Vectored port elemnt */
581  port = std::string(inp, dot_i + 1, (open_square_i - 1) - dot_i);
582  index = std::atoi(inp.c_str() + open_square_i + 1);
583  }
584  }
585 }
586 
587 void
589 {
590  for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++i)
591  ((*i)->*mem_func)();
592 }
593 
594 void
596 {
597  if (build_all) {
598  findAllObjects();
599  bindAllPorts();
600  }
601 
602  DPRINTF(CxxConfig, "Initialising all objects\n");
604 
605  DPRINTF(CxxConfig, "Registering stats\n");
607 
608  DPRINTF(CxxConfig, "Registering probe points\n");
610 
611  DPRINTF(CxxConfig, "Connecting probe listeners\n");
613 }
614 
615 void
617 {
618  DPRINTF(CxxConfig, "Calling initState on all objects\n");
620 }
621 
622 void
624 {
625  DPRINTF(CxxConfig, "Starting up all objects\n");
627 }
628 
629 unsigned int
631 {
632  return DrainManager::instance().tryDrain() ? 0 : 1;
633 }
634 
635 void
637 {
639 }
640 
641 void
643 {
644  for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++ i) {
645  // (*i)->nameOut(os); FIXME, change access spec. for nameOut
646  os << '[' << (*i)->name() << "]\n";
647  (*i)->serialize(os);
648  }
649 }
650 
651 void
653 {
654  for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++ i)
655  (*i)->loadState(checkpoint);
656 }
657 
658 void
660 {
661  for (auto i = objectsInOrder.rbegin(); i != objectsInOrder.rend(); ++i) {
662  DPRINTF(CxxConfig, "Freeing sim object: %s\n", (*i)->name());
663  delete *i;
664  }
665 
666  for (auto i = objectParamsByName.rbegin();
667  i != objectParamsByName.rend(); ++i)
668  {
669  CxxConfigParams *params = (*i).second;
670 
671  DPRINTF(CxxConfig, "Freeing sim object params: %s\n",
672  params->getName());
673  delete params;
674  }
675 
676  objectsInOrder.clear();
677  objectsByName.clear();
678 }
679 
680 void
681 CxxConfigManager::setParam(const std::string &object_name,
682  const std::string &param_name, const std::string &param_value)
683 {
684  CxxConfigParams *params = findObjectParams(object_name);
685 
686  if (!params->setParam(param_name, param_value, flags)) {
687  throw Exception(object_name, csprintf("Bad parameter value:"
688  " .%s=X=\"%s\"", param_name, param_value));
689  } else {
690  std::string instance_name = rename(object_name);
691 
692  DPRINTF(CxxConfig, "Setting parameter %s.%s=%s\n",
693  instance_name, param_name, param_value);
694  }
695 }
696 
697 void
698 CxxConfigManager::setParamVector(const std::string &object_name,
699  const std::string &param_name,
700  const std::vector<std::string> &param_values)
701 {
702  CxxConfigParams *params = findObjectParams(object_name);
703 
704  if (!params->setParamVector(param_name, param_values, flags)) {
705  throw Exception(object_name, csprintf("Bad vector parameter value:"
706  " .%s=X=\"%s\"", param_name, formatParamList(param_values)));
707  } else {
708  std::string instance_name = rename(object_name);
709 
710  DPRINTF(CxxConfig, "Setting parameter %s.%s=\"%s\"\n",
711  instance_name, param_name, formatParamList(param_values));
712  }
713 }
714 
716 {
717  renamings.push_back(renaming);
718 }
719 
720 } // namespace gem5
gem5::DrainManager::instance
static DrainManager & instance()
Get the singleton DrainManager instance.
Definition: drain.hh:91
gem5::CxxConfigFileBase::getAllObjectNames
virtual void getAllObjectNames(std::vector< std::string > &list) const =0
Get all SimObjects in the config.
gem5::PortID
int16_t PortID
Port index/ID type, and a symbolic name for an invalid port id.
Definition: types.hh:252
gem5::SimObject::getPort
virtual Port & getPort(const std::string &if_name, PortID idx=InvalidPortID)
Get a port with a given name and index.
Definition: sim_object.cc:126
gem5::CxxConfigManager::Renaming::fromPrefix
std::string fromPrefix
Definition: cxx_manager.hh:103
gem5::CxxConfigFileBase::getPortPeers
virtual bool getPortPeers(const std::string &object_name, const std::string &port_name, std::vector< std::string > &peers) const =0
Get the peer (connected) ports of the named ports.
gem5::CxxConfigManager::renamings
std::list< Renaming > renamings
All the renamings applicable when instantiating objects.
Definition: cxx_manager.hh:129
gem5::SimObject::initState
virtual void initState()
initState() is called on each SimObject when not restoring from a checkpoint.
Definition: sim_object.cc:94
serialize.hh
gem5::CxxConfigManager::objectsByName
std::map< std::string, SimObject * > objectsByName
SimObject indexed by name.
Definition: cxx_manager.hh:115
gem5::formatParamList
static std::string formatParamList(const std::vector< std::string > &param_values)
Definition: cxx_manager.cc:111
gem5::MipsISA::index
Bitfield< 30, 0 > index
Definition: pra_constants.hh:47
gem5::CxxConfigManager::deleteObjects
void deleteObjects()
Delete all objects and clear objectsByName and objectsByOrder.
Definition: cxx_manager.cc:659
gem5::CxxConfigManager::bindObjectPorts
void bindObjectPorts(SimObject *object)
Bind the ports of a single SimObject.
Definition: cxx_manager.cc:522
gem5::CxxConfigManager::unRename
std::string unRename(const std::string &to_name)
Apply the first matching renaming in reverse (toPrefix -> fromPrefix for the given name.
Definition: cxx_manager.cc:96
gem5::CxxConfigParams::setPortConnectionCount
virtual bool setPortConnectionCount(const std::string &name, unsigned int count)
Set the number of connections expected for the named port.
Definition: cxx_config.hh:175
gem5::CheckpointIn
Definition: serialize.hh:68
gem5::CxxConfigParams::setSimObject
virtual bool setSimObject(const std::string &name, SimObject *simObject)
Set a SimObject valued parameter with a reference to the given SimObject.
Definition: cxx_config.hh:150
gem5::CxxConfigDirectoryEntry::parameters
std::map< std::string, ParamDesc * > parameters
All parameters (including SimObjects) in order.
Definition: cxx_config.hh:111
gem5::CxxConfigManager::flags
CxxConfigParams::Flags flags
Flags to pass to affect param setting.
Definition: cxx_manager.hh:76
gem5::SimObject::init
virtual void init()
init() is called after all C++ SimObjects have been created and all ports are connected.
Definition: sim_object.cc:76
gem5::CxxConfigManager::bindPort
void bindPort(SimObject *requestorObject, const std::string &requestPort, PortID requestPortIndex, SimObject *responderObject, const std::string &responsePort, PortID responsePortIndex)
Bind a single connection between two objects' ports.
Definition: cxx_manager.cc:449
gem5::CxxConfigManager::parsePort
static void parsePort(const std::string &inp, std::string &path, std::string &port, unsigned int &index)
Parse a port string of the form 'path(.path)*.port[index]' into path, port and index.
Definition: cxx_manager.cc:561
gem5::CxxConfigManager::bindRequestPort
void bindRequestPort(SimObject *object, const CxxConfigDirectoryEntry::PortDesc &port, const std::vector< std::string > &peers)
Bind a single (possibly vectored) request port to peers from the unparsed list peers with elements in...
Definition: cxx_manager.cc:486
gem5::CxxConfigParams
Base for peer classes of SimObjectParams derived classes with parameter modifying member functions.
Definition: cxx_config.hh:126
gem5::CxxConfigManager::findAllObjects
void findAllObjects()
Find all objects by iterating over the object names in the config file with findObject.
Definition: cxx_manager.cc:414
gem5::CxxConfigManager::addRenaming
void addRenaming(const Renaming &renaming)
Add a name prefix renaming to those currently applied.
Definition: cxx_manager.cc:715
gem5::CxxConfigDirectoryEntry::PortDesc::name
const std::string name
Definition: cxx_config.hh:96
gem5::CxxConfigManager::findObject
SimObject * findObject(const std::string &object_name, bool visit_children=false)
Walk the configuration starting with object object_name and fill in all the elements of this object o...
Definition: cxx_manager.cc:132
std::vector< std::string >
gem5::csprintf
std::string csprintf(const char *format, const Args &...args)
Definition: cprintf.hh:161
gem5::CxxConfigManager::Renaming::toPrefix
std::string toPrefix
Definition: cxx_manager.hh:104
gem5::ArmISA::i
Bitfield< 7 > i
Definition: misc_types.hh:66
gem5::CxxConfigDirectoryEntry::makeParamsObject
virtual CxxConfigParams * makeParamsObject() const
Make a ...Param structure for the SimObject class of this entry.
Definition: cxx_config.hh:117
gem5::Port::bind
virtual void bind(Port &peer)
Attach to a peer port.
Definition: port.hh:118
gem5::CxxConfigFileBase::getParamVector
virtual bool getParamVector(const std::string &object_name, const std::string &param_name, std::vector< std::string > &values) const =0
Get a list/vector parameter.
gem5::CxxConfigManager::forEachObject
void forEachObject(void(SimObject::*mem_func)())
Perform mem_func on each SimObject.
Definition: cxx_manager.cc:588
str.hh
cxx_manager.hh
gem5::CxxConfigManager::objectParamsByName
std::map< std::string, CxxConfigParams * > objectParamsByName
...Params objects created by this manager
Definition: cxx_manager.hh:118
gem5::CxxConfigManager::findObjectParams
CxxConfigParams * findObjectParams(const std::string &object_name)
Find the parameters for the named object.
Definition: cxx_manager.cc:266
gem5::cxx_config_directory
std::map< std::string, CxxConfigDirectoryEntry * > cxx_config_directory
Directory of all SimObject classes config details.
Definition: cxx_config.cc:46
gem5::CxxConfigManager::serialize
void serialize(std::ostream &os)
Serialize (checkpoint) all objects to the given stream.
Definition: cxx_manager.cc:642
gem5::CxxConfigManager::objectsInOrder
std::list< SimObject * > objectsInOrder
SimObjects in order.
Definition: cxx_manager.hh:121
gem5::CxxConfigManager::setParamVector
void setParamVector(const std::string &object_name, const std::string &param_name, const std::vector< std::string > &param_values)
Definition: cxx_manager.cc:698
gem5::CxxConfigManager::inVisit
std::set< std::string > inVisit
While configuring, inVisit contains names of SimObjects visited in this recursive configuration walk.
Definition: cxx_manager.hh:126
gem5::CxxConfigManager::startup
void startup()
Call startup on all objects.
Definition: cxx_manager.cc:623
gem5::CxxConfigFileBase::getParam
virtual bool getParam(const std::string &object_name, const std::string &param_name, std::string &value) const =0
Get a single parameter value as a string returned in value.
gem5::CxxConfigDirectoryEntry::ParamDesc::name
const std::string name
Definition: cxx_config.hh:77
gem5::Named::name
virtual std::string name() const
Definition: named.hh:47
gem5::CxxConfigDirectoryEntry::PortDesc::isVector
const bool isVector
Definition: cxx_config.hh:99
gem5::CxxConfigManager::CxxConfigManager
CxxConfigManager(CxxConfigFileBase &configFile_)
Definition: cxx_manager.cc:52
sim_object.hh
DPRINTF
#define DPRINTF(x,...)
Definition: trace.hh:186
gem5::CxxConfigManager::Exception
Exception for instantiate/post-instantiate errors.
Definition: cxx_manager.hh:80
gem5::CxxConfigManager::findTraversalOrder
void findTraversalOrder(const std::string &object_name)
Populate objectsInOrder with a preorder, depth first traversal from the given object name down throug...
Definition: cxx_manager.cc:425
gem5::Port::isConnected
bool isConnected() const
Is this port currently connected to a peer?
Definition: port.hh:133
gem5::CxxConfigDirectoryEntry::ParamDesc::isVector
const bool isVector
Definition: cxx_config.hh:80
gem5::SimObject
Abstract superclass for simulation objects.
Definition: sim_object.hh:146
gem5::CxxConfigDirectoryEntry::PortDesc
Similar to ParamDesc to describe ports.
Definition: cxx_config.hh:93
gem5::CxxConfigManager::drainResume
void drainResume()
Resume from drain.
Definition: cxx_manager.cc:636
gem5::CxxConfigDirectoryEntry::ports
std::map< std::string, PortDesc * > ports
Ports.
Definition: cxx_config.hh:114
gem5::CxxConfigManager::Renaming
Name substitution when instantiating any object whose name starts with fromPrefix.
Definition: cxx_manager.hh:101
gem5::statistics::Group::regStats
virtual void regStats()
Callback to set stat parameters.
Definition: group.cc:69
gem5::CxxConfigManager::drain
unsigned int drain()
Drain all objects.
Definition: cxx_manager.cc:630
gem5::CxxConfigManager::loadState
void loadState(CheckpointIn &checkpoint)
Load all objects' state from the given Checkpoint.
Definition: cxx_manager.cc:652
gem5::CxxConfigFileBase
Config file wrapper providing a common interface to CxxConfigManager.
Definition: cxx_config.hh:188
gem5::CxxConfigManager::initState
void initState()
Call initState on all objects.
Definition: cxx_manager.cc:616
gem5::DrainManager::tryDrain
bool tryDrain()
Try to drain the system.
Definition: drain.cc:64
gem5::CxxConfigManager::bindAllPorts
void bindAllPorts()
Bind the ports of all the objects in objectInOrder order.
Definition: cxx_manager.cc:442
gem5::CxxConfigParams::getName
virtual const std::string & getName()
Get full path name string.
Definition: cxx_config.hh:145
gem5::CxxConfigFileBase::objectExists
virtual bool objectExists(const std::string &object_name) const =0
Does an object with this path exist?
gem5::SimObject::regProbeListeners
virtual void regProbeListeners()
Register probe listeners for this object.
Definition: sim_object.cc:115
gem5::DrainManager::resume
void resume()
Resume normal simulation in a Drained system.
Definition: drain.cc:96
gem5::CxxConfigParams::setName
virtual void setName(const std::string &name_)
Example flag.
Definition: cxx_config.hh:142
gem5::CxxConfigManager::configFile
CxxConfigFileBase & configFile
Configuration file being read.
Definition: cxx_manager.hh:73
gem5::Port
Ports are used to interface objects to each other.
Definition: port.hh:61
gem5::CxxConfigFileBase::getObjectChildren
virtual void getObjectChildren(const std::string &object_name, std::vector< std::string > &children, bool return_paths=false) const =0
Get the names or paths of all the children SimObjects of this SimObject.
gem5::ArmISA::n
Bitfield< 31 > n
Definition: misc_types.hh:455
gem5::SimObject::startup
virtual void startup()
startup() is the final initialization call before simulation.
Definition: sim_object.cc:99
gem5::X86ISA::os
Bitfield< 17 > os
Definition: misc.hh:809
gem5::CxxConfigManager::rename
std::string rename(const std::string &from_name)
Apply the first matching renaming in renamings to the given name.
Definition: cxx_manager.cc:81
gem5::CxxConfigDirectoryEntry
Config details entry for a SimObject.
Definition: cxx_config.hh:69
gem5::CxxConfigManager::instantiate
void instantiate(bool build_all=true)
Build all objects (if build_all is true, otherwise objects must have been individually findObject-ed ...
Definition: cxx_manager.cc:595
gem5::CxxConfigParams::setParamVector
virtual bool setParamVector(const std::string &name, const std::vector< std::string > &values, const Flags flags)
As setParamVector but for parameters given as vectors pre-separated into elements.
Definition: cxx_config.hh:169
gem5::CxxConfigDirectoryEntry::ParamDesc
Definition: cxx_config.hh:74
trace.hh
gem5::CxxConfigDirectoryEntry::ParamDesc::isSimObject
const bool isSimObject
Is this a SimObject, and so is to be set with setSimObject...
Definition: cxx_config.hh:84
gem5::SimObject::regProbePoints
virtual void regProbePoints()
Register probe points for this object.
Definition: sim_object.cc:107
gem5::CxxConfigManager::findObjectType
const CxxConfigDirectoryEntry & findObjectType(const std::string &object_name, std::string &object_type)
Find the type field for a named object and return both the name of the type to object_type and the ob...
Definition: cxx_manager.cc:59
gem5
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
Definition: decoder.cc:40
gem5::CxxConfigParams::setParam
virtual bool setParam(const std::string &name, const std::string &value, const Flags flags)
Set a parameter with a value parsed from the given string.
Definition: cxx_config.hh:163
gem5::CxxConfigParams::simObjectCreate
virtual SimObject * simObjectCreate()
Create the associated SimObject.
Definition: cxx_config.hh:180
gem5::CxxConfigParams::setSimObjectVector
virtual bool setSimObjectVector(const std::string &name, const std::vector< SimObject * > &simObjects)
As setSimObjectVector but set a whole vector of references.
Definition: cxx_config.hh:155
gem5::CxxConfigDirectoryEntry::PortDesc::isRequestor
const bool isRequestor
Is this a request or response port.
Definition: cxx_config.hh:102
gem5::CxxConfigManager::setParam
void setParam(const std::string &object_name, const std::string &param_name, const std::string &param_value)
Convenience functions for calling set...
Definition: cxx_manager.cc:681

Generated on Tue Sep 21 2021 12:25:47 for gem5 by doxygen 1.8.17