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

Complete this section

Parsing
Formats/extending

Write 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)

Support vectors of windows with holes

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

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

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

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

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

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

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

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

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)

Support compression

canDelete is recursive at worst and might benefit from optimization

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)