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,
                          TraceEventNodeRefPtrVector&& children,
                          const bool separateEvents) {
        return TfCreateRefPtr(
            new TraceEventNode(
                key,
                category,
                beginTime,
                endTime,
                std::move(children),
                separateEvents));
    }
 
    TRACE_API TraceEventNodeRefPtr Append(const TfToken &key, 
                                          TraceCategoryId category,
                                          TimeStamp beginTime,
                                          TimeStamp endTime,
                                          bool separateEvents);
    
    TRACE_API void 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; }
 
 
 
    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() {
        if (AttributeMap *attrMap = _attributesAndSeparateEvents.Get()) {
            _DeleteAttrMap(attrMap);
        }
    }
 
private:
 
    TraceEventNode(
        const TfToken &key,
        TraceCategoryId category,
        TimeStamp beginTime, 
        TimeStamp endTime,
        TraceEventNodeRefPtrVector&& children,
        bool separateEvents)
 
        : _category(category)
        , _key(key)
        , _beginTime(beginTime)
        , _endTime(endTime)
        , _children(std::make_move_iterator(children.begin()),
                    std::make_move_iterator(children.end()))
        , _attributesAndSeparateEvents(nullptr, separateEvents)
    {
    }
 
    // Out-of-line to avoid inlining the multimap dtor code.
    TRACE_API void _DeleteAttrMap(AttributeMap *attrMap);
 
    // _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