Page Logging Output formats (.log, .log.raw, .log.basic, log.verbose)

Write this page

Page Sparta Command Line Interface End-User Guide

Write this section

Configuration
Traces
Run Control
Notifications
Inspecting configuration
Showing the tree
Writing configuration

Write this section

Complete this section

Parsing
Formats/extending

Write this section

Complete this section

Member sparta::app::NodeConfigFileApplicator::tryApply (sparta::TreeNode *root, ApplySuccessCondition asc, ApplyFilter filter=ApplyFilter(), bool verbose=false) const override

Allow meta-data attached to virtual parameter trees

Support tracking of set parameters and error on 0-paramerters set based on ASC_ policy.

Member sparta::app::ParameterApplicator::tryApply (sparta::TreeNode *root, ApplySuccessCondition required, ApplyFilter filter, bool verbose) const override

Allow meta-data attached to virtual parameter trees

Member sparta::app::ParameterDefaultApplicator::tryApply (sparta::TreeNode *root, ApplySuccessCondition required, ApplyFilter filter=ApplyFilter(), bool verbose=false) const override

Allow meta-data attached to virtual parameter trees

Member sparta::bounded_int< T, min_bound, max_bound >::operator T () const

Add static methods to convert a value using additional bounds. A new bounded value can be constructed to achieve this as well.

Member sparta::ClockManager::makeRoot (RootTreeNode *parent=nullptr, const std::string &name="Root")

Implement special case for RootClock that avoids this extra level

Member sparta::collection::PipelineCollector::PipelineCollector (const std::string &filepath, Scheduler::Tick heartbeat_interval, const sparta::Clock *root_clk, const sparta::TreeNode *root, Scheduler *scheduler=nullptr)

The multiplier should also be scaled slightly by the number of locations registered in order to better estimate the ideal heartbeat size.

Member sparta::Counter::get () const override

Allow indexed accesses if larger counters are supported.

Member sparta::Counter::increment (counter_type add)

Allow indexed accesses if larger counters are supported

Member sparta::Counter::operator++ ()

Allow indexed accesses if larger counters are supported

Member sparta::Counter::operator++ (int)

Allow indexed accesses if larger counters are supported

Member sparta::Counter::set (counter_type val)

Allow indexed accesses if larger counters are supported

Member sparta::CounterBase::get () const =0

Allow indexed accesses if larger counters are supported.

Member sparta::CycleCounter::get () const override

Allow indexed accesses if larger counters are supported.

Class sparta::DataOutPort< DataT >

Add support for requiring bounded ports

Add support for automatic collection

Member sparta::DataView::place_ (offset_type offset) override

Store pointer directly to value to save an add in offset

Class sparta::log::MessageSource

Must understand current thread + sequence within that thread

Member sparta::memory::BlockingMemoryIF::BlockingMemoryIF (const std::string &desc, addr_t block_size, const DebugMemoryIF::AccessWindow &window, TranslationIF *transif=nullptr)

Support vectors of windows with holes

Member sparta::memory::DebugMemoryIF::DebugMemoryIF (const std::string &desc, addr_t block_size, const AccessWindow &window, TranslationIF *transif=nullptr)

Check for access window overlaps (once multiple windows are supported)

Create lookup map for identifying holes if more than 1 window is allowed

Support vectors of windows with holes

Member sparta::memory::TranslationIF::translate (const addr_t &addr, Translation *trans=nullptr) const

Determine failure cause.

Class sparta::memory::TranslationIFNode

Add sparta Notification support

Class sparta::NotificationSourceBase::ObservationStateCallback

Aoply this pattern (with code re-use) to Counter types as well so that Counter-incrementing code can change it's behavior and granularity to better support counter-based SPARTA tirggers

Add a multi-callback version of this class that handles both sole-[de]registering functions and both any-[de]registering functions

Member sparta::Parameter< ValueType >::operator= (const ValueType &v)

Perform independent parameter validation and throw exception if failed.

Member sparta::ParameterBase::ParameterBase (const std::string &name, const std::string &desc)

Check that parent is a ParameterSet

Class sparta::ParameterSet

Deduce set of fields using boost::fusion or other instrospection fields instead of the current __collect method.

Allow defaulting the numeric display base for entire set (like sparta::Parameter::setNumericDisplayBase)

Member sparta::ParameterSet::addParameter_ (sparta::ParameterBase *p)

This must be done automatically by onAddingChild_ and not explicitly by anyone except ParametersThemselves

Member sparta::ParameterSet::dumpList () const

This should be optimized to store fields in a matrix such that each string isn't rendered twice

Member sparta::ParameterSet::readValueFromVirtualTree_ (const ParameterTree *arch_pt, const ParameterTree *pt, sparta::ParameterBase *p)

Merge this into ParameterBase construction if possible

Member sparta::PhasedObject::setPhase_ (TreePhase phase)

Enforce phas ordering here

Member sparta::ReadOnlyCounter::get () const override

Allow indexed accesses if larger counters are supported.

Member sparta::RegisterBankTable< RegisterT >::addRegister (RegisterT *r)

Use logger

Class sparta::RegisterBase

Add register notifications between compound registers

Struct sparta::RegisterBase::Definition

Add omitted fields:

Struct sparta::RegisterBase::Field::Definition

Add reserved field (or other missing attributes)

Member sparta::RegisterBase::Field::peek () const

Support indexes for reading more than access_type elements

Support reading with different integer sizes

Member sparta::RegisterBase::Field::poke (access_type t)

Support indexes for reading more than access_type elements

Support reading with different integer sizes

Member sparta::RegisterBase::Field::read ()

Support indexes for reading more than access_type elements

Support reading with different integer sizes

Member sparta::RegisterBase::Field::write (access_type t)

Support indexes for reading more than access_type elements

Support reading with different integer sizes

Class sparta::RegisterProxy

Access a register

Member sparta::ResourceTreeNode::createResource_ () override

Move this check to the actual setting of the resources. ResourceTreeNode should hook into ResourceContainer's method to prevent setting of a resource externally

Check for orphaned trees (no common parent). Defining nodes with "top" semantics would simplify this.

Member sparta::ResourceTreeNode::ResourceTreeNode (TreeNode *parent, const std::string &name, const std::string &group, group_idx_type group_idx, const std::string &desc, ResourceFactoryBase *res_fact)

desc should come from the resource factory as a common const char*.

Member sparta::RootTreeNode::bindTreeEarly ()

Prevent this from being called when the simulation is running

Member sparta::RootTreeNode::dumpDebugContent (std::ostream &out) noexcept

Replace this method with a method that places all output into different files within a subfolder

Member sparta::Scheduler::stopRunning ()

Change the granularity of when the scheduler stops running so that it must finish the tick.

Member sparta::serialization::checkpoint::Checkpointer::dumpBranch (std::ostream &o, const Checkpoint *chkpt, uint32_t indent, uint32_t pos, std::deque< uint32_t > &continues) const

Move the constants somewhere static outside this function (especially the assert)

Member sparta::serialization::checkpoint::Checkpointer::findCheckpoint_ (chkpt_id_t id) noexcept=0

Faster lookup?

Class sparta::serialization::checkpoint::DeltaCheckpoint< StorageT >

Store reverse deltas additional (or maybe instead) so that rewind is quicker

Class sparta::serialization::checkpoint::FastCheckpointer

Implement reverse delta storage for backward checkpoint loading

Tune ArchData line size based on checkpointer performance

More profiling

Compression

Saving to disk using a templated checkpoint object storage class (allowing for non-binary)

Member sparta::serialization::checkpoint::FastCheckpointer::cleanupChain_ (checkpoint_type *d)

canDelete is recursive at worst and might benefit from optimization

Support compression

Member sparta::serialization::checkpoint::FastCheckpointer::findCheckpoint_ (chkpt_id_t id) noexcept override

Faster lookup?

Member sparta::SimulationInfo::setCommandLine (int argc, char **argv)

Re-escape quotes or remove need for quotes by escaping everything

Class sparta::SysCSpartaSchedulerAdapter

The Sparta scheduler is on its own SC_THREAD and is put to sleep between scheduled events. For example, if the Sparta scheduler has an event scheduled @ tick 1000, and time is currently 500, the Sparta scheduler thread will wait() for 500 ticks. However, if a SystemC component puts an event on the Sparta scheduler during this sleep window (say at 750 ticks), we do not have a mechanism to wake this thread early.

Class sparta::TieredMap< KeyT, ValT >

Improve iteration to reduce memory use. Instead of maintaining a separate list of pairs, walk the tree itself. However, reasonably fast iteration is needed for checkpointing, so the extra memory use may be somewhat justified

Member sparta::TieredMap< KeyT, ValT >::node_t

Memory can be further saved by making this sparse itself. Most easily, a start index can be stored in addition to the vector's size.

More memory might be saved by making this a simple array instead of a vector. Performance in debug mode would definitely increase because of the removed bounds checking

Member sparta::TreeNode::CHILD_FIND_THRESHOLD

getChild/findChildren should know the difference between report-based accesses and model-based accesses so that this can be conditionally incremented

Member sparta::TreeNode::getChildrenIdentifiers (std::vector< std::string > &idents, bool ignore_builtin_group=true) const

Allow groups to be retrieved witih getChild

Member sparta::TreeNode::getGroup (const std::string &group, std::vector< TreeNode * > &results)

Optimize lookup by group using mappings

Member sparta::TreeNode::getGroupIndexMax (const std::string &group)

Optimize this count by storing group mappings

Member sparta::TreeNode::getGroupSize (const std::string &group)

Optimize this count by storing group sizes (or group vectors) in TreeNode.

Member sparta::TreeNode::registerForNotification (T *obj, const std::string &name, bool ensure_possible=true)

Faster attachment of delegates to children. There is notable performance impact today, however.

Member sparta::utils::computeOutputFilename (const std::string &name, const std::string &location, uint32_t idx, const std::string &sim_name)

Create a file manager

Member sparta::utils::smartLexicalCast (const std::string &s, size_t &end_pos, bool allow_recursion=true, bool allow_prefix=true)

To resolve prefix/suffix ambiguity and allow stringing together multiple value with prefixes support could be added for '+' as a disamgiuator (e.g. 50+0b111)