eventNode.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_EVENT_NODE_H
#define PXR_BASE_TRACE_EVENT_NODE_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/trace/api.h"
#include "pxr/base/trace/event.h"
#include "pxr/base/trace/eventData.h"
 
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/tf/pointerAndBits.h"
#include "pxr/base/tf/refBase.h"
#include "pxr/base/tf/refPtr.h"
#include "pxr/base/tf/smallVector.h"
#include "pxr/base/tf/span.h"
#include "pxr/base/tf/token.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
TF_DECLARE_REF_PTRS(TraceEventNode);
 
 
class TraceEventNode : public TfSimpleRefBase {
public:
 
    using TimeStamp = TraceEvent::TimeStamp;
    using AttributeData = TraceEventData;
    using AttributeMap = std::multimap<TfToken, AttributeData>;
 
    TRACE_API static TraceEventNodeRefPtr New();
    
    static TraceEventNodeRefPtr New(const TfToken &key,
                                    const TraceCategoryId category,
                                    const TimeStamp beginTime,
                                    const TimeStamp endTime,
                                    const bool separateEvents) {
        return TfCreateRefPtr(
            new TraceEventNode(
                key, category, beginTime, endTime, separateEvents)
            );
    }
 
    TRACE_API void Append(TraceEventNodeRefPtr &&node);
 
    void Append(const TraceEventNodeRefPtr &node) {
        Append(TraceEventNodeRefPtr { node });
    }
    
    const TfToken &GetKey() const { return _key; }
 
    TraceCategoryId GetCategory() const { return _category; }
 
    TRACE_API void SetBeginAndEndTimesFromChildren();
 
 
    TimeStamp GetBeginTime() const { return _beginTime; }
 
    TimeStamp GetEndTime() const { return _endTime; }
 
    TimeStamp GetTimeDuration() const { return _endTime - _beginTime; }
 
 
 
    TfSpan<const TraceEventNodeRefPtr> GetChildrenRef() const {
        return _children;
    }
 
 
    TRACE_API const AttributeMap& GetAttributes() const;
 
    TRACE_API void AddAttribute(const TfToken& key, AttributeData&& attr);
 
    bool IsFromSeparateEvents() const {
        return _attributesAndSeparateEvents.BitsAs<bool>();
    }
 
    ~TraceEventNode() override;
 
private:
    friend class Trace_EventTreeBuilder;
 
    void _SetIsSeparateEvents(bool isSeparate) {
        _attributesAndSeparateEvents.SetBits(isSeparate);
    }
 
    TraceEventNode(const TfToken &key,
                   TraceCategoryId category,
                   TimeStamp beginTime, 
                   TimeStamp endTime,
                   bool separateEvents)
        : _category(category)
        , _key(key)
        , _beginTime(beginTime)
        , _endTime(endTime)
        , _attributesAndSeparateEvents(nullptr, separateEvents)
    {
    }
 
    // _category (4 bytes) is first so it packs with TfRefBase's 4-byte count.
    const TraceCategoryId _category;
    const TfToken _key;
    TimeStamp _beginTime;
    TimeStamp _endTime;
    // Empirical results show ~85% of nodes have < 2 children.
    TfSmallVector<TraceEventNodeRefPtr, 1> _children;
    TfPointerAndBits<AttributeMap> _attributesAndSeparateEvents;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TRACE_EVENT_NODE_H