aggregateNode.h

//
// Copyright 2018 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_BASE_TRACE_AGGREGATE_NODE_H
#define PXR_BASE_TRACE_AGGREGATE_NODE_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/trace/api.h"
#include "pxr/base/trace/event.h"
#include "pxr/base/trace/threads.h"
 
#include "pxr/base/tf/refBase.h"
#include "pxr/base/tf/refPtr.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/base/tf/weakPtr.h"
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/arch/timing.h"
 
#include <vector>
#include "pxr/base/tf/denseHashMap.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
TF_DECLARE_WEAK_AND_REF_PTRS(TraceAggregateNode);
 
 
class TraceAggregateNode : public TfRefBase, public TfWeakBase {
public:
 
    using This = TraceAggregateNode;
    using ThisPtr = TraceAggregateNodePtr;
    using ThisRefPtr = TraceAggregateNodeRefPtr;
 
    using TimeStamp = TraceEvent::TimeStamp;
 
    static ThisRefPtr New() {
        return This::New(TfToken("root"), 0, 0);
    }
 
    static ThisRefPtr New(const TfToken &key,
                          const TimeStamp ts,
                          const int count = 1,
                          const int exclusiveCount = 1) {
        return TfCreateRefPtr(new This(key, ts, count, exclusiveCount));
    }
 
    TRACE_API TraceAggregateNodeRefPtr 
    Append(const TfToken &key, TimeStamp ts,int c = 1, int xc = 1);
 
    // Same as Append() but return nothing.
    TRACE_API void
    AppendBlind(const TfToken &key, TimeStamp ts, int c = 1, int xc = 1);
 
    TRACE_API void Append(TraceAggregateNodeRefPtr child);
 
    const TfToken& GetKey() { return _key;}
 
 
    TimeStamp GetInclusiveTime() { return _ts; }
 
    TRACE_API TimeStamp GetExclusiveTime(bool recursive = false);
 
    int GetCount(bool recursive = false) const {
        return recursive ? _recursiveCount : _count; 
    }
 
    int GetExclusiveCount() const { return _exclusiveCount; }
 
 
 
 
    TRACE_API void AppendInclusiveCounterValue(int index, double value);
 
    TRACE_API double GetInclusiveCounterValue(int index) const;
 
    TRACE_API void AppendExclusiveCounterValue(int index, double value);
 
    TRACE_API double GetExclusiveCounterValue(int index) const;
 
 
    TRACE_API void CalculateInclusiveCounterValues();
 
 
    const TraceAggregateNodePtrVector GetChildren() {
        // convert to a vector of weak ptrs
        return TraceAggregateNodePtrVector( _children.begin(),_children.end() );
    }
 
    const TraceAggregateNodeRefPtrVector &GetChildrenRef() {
        return _children;
    }
 
    TRACE_API TraceAggregateNodeRefPtr GetChild(const TfToken &key);
    TraceAggregateNodeRefPtr GetChild(const std::string &key) {
        return GetChild(TfToken(key));
    }
 
 
 
    void SetExpanded(bool expanded) {
        _expanded = expanded;
    }
 
    bool IsExpanded() {
        return _expanded;
    }
 
    TRACE_API void AdjustForOverheadAndNoise(
        TimeStamp scopeOverhead, TimeStamp timerQuantum,
        uint64_t *numDescendantNodes = nullptr);
 
 
    TRACE_API void MarkRecursiveChildren();
 
    bool IsRecursionMarker() const { return _isRecursionMarker; }
 
    bool IsRecursionHead() const { return _isRecursionHead; }
 
 
 
private:
 
    TraceAggregateNode(const TfToken &key, TimeStamp ts,
              int count, int exclusiveCount) :
        _key(key), _ts(ts), _exclusiveTs(ts),
        _count(count), _exclusiveCount(exclusiveCount),
        _recursiveCount(count), _recursiveExclusiveTs(ts), _expanded(false), 
        _isRecursionMarker(false), _isRecursionHead(false),
        _isRecursionProcessed(false) {}
 
    using _ChildDictionary = TfDenseHashMap<TfToken, size_t, TfHash>;
 
    void _MergeRecursive(const TraceAggregateNodeRefPtr &node);
 
    void _SetAsRecursionMarker(TraceAggregateNodePtr parent);
 
    TraceAggregateNode *_GetChildRaw(const TfToken &key);
    
    const TfToken _key;
    TimeStamp _ts;  
    TimeStamp _exclusiveTs;
    int _count;
    int _exclusiveCount;
 
    // We keep the recursive counts separate so that we don't mess with 
    // the collected data.
    int _recursiveCount;
    TraceAggregateNodePtr _recursionParent;
    TimeStamp _recursiveExclusiveTs;
 
    TraceAggregateNodeRefPtrVector _children;
    _ChildDictionary _childrenByKey;
 
    // A structure that holds on to the inclusive and exclusive counter
    // values. These values are usually populated together, so it's beneficial
    // to maintain them in a tightly packed structure.
    struct _CounterValue {
        _CounterValue() : inclusive(0.0), exclusive(0.0) {}
        double inclusive;
        double exclusive;
    };
 
    using _CounterValues = TfDenseHashMap<int, _CounterValue, TfHash>;
 
    // The counter values associated with specific counter indices
    _CounterValues _counterValues;
    
    unsigned int
    // If multiple Trace Editors are to be pointed at the same Reporter, this
    // might have to be changed
                _expanded:1,
 
    // This flag keeps track of whether or not this node is simply intended
    // as a marker for the start of a recursive call tree.
                _isRecursionMarker:1,
 
    // This flag keeps track of whether or not a node is the head of a
    // recursive call tree.  In other words, if it is a function that has been
    // called recursively.
                _isRecursionHead:1,
 
    // This flag is used during recursive traversal to mark the node as having 
    // been visited and avoid too much processing.
                _isRecursionProcessed:1;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TRACE_AGGREGATE_NODE_H