reporter.h

//
// Copyright 2018 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
 
#ifndef PXR_BASE_TRACE_REPORTER_H
#define PXR_BASE_TRACE_REPORTER_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/trace/api.h"
#include "pxr/base/trace/event.h"
#include "pxr/base/trace/aggregateNode.h"
#include "pxr/base/trace/reporterBase.h"
 
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/tf/mallocTag.h"
#include "pxr/base/tf/staticTokens.h"
 
#include <iosfwd>
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
#define TRACE_REPORTER_TOKENS       \
    ((warningString, "WARNING:"))
 
TF_DECLARE_PUBLIC_TOKENS(TraceReporterTokens, TRACE_API, TRACE_REPORTER_TOKENS);
 
 
TF_DECLARE_WEAK_AND_REF_PTRS(TraceAggregateTree);
TF_DECLARE_WEAK_AND_REF_PTRS(TraceEventNode);
TF_DECLARE_WEAK_AND_REF_PTRS(TraceEventTree);
 
TF_DECLARE_WEAK_AND_REF_PTRS(TraceReporter);
 
class TraceCollectionAvailable;
 
class TraceReporter : 
    public TraceReporterBase {
public:
 
    TF_MALLOC_TAG_NEW("Trace", "TraceReporter");
    
    using This = TraceReporter;
    using ThisPtr = TraceReporterPtr;
    using ThisRefPtr = TraceReporterRefPtr;
 
    using Event = TraceEvent;
    using TimeStamp = TraceEvent::TimeStamp;
    using CounterMap = TfHashMap<TfToken, double, TfToken::HashFunctor>;
 
    static ThisRefPtr New(const std::string& label,
                          DataSourcePtr dataSource) {
        return TfCreateRefPtr(new This(label, std::move(dataSource)));
    }
 
    static ThisRefPtr New(const std::string& label) {
        return TfCreateRefPtr(new This(label, nullptr));
    }
 
    TRACE_API static TraceReporterPtr GetGlobalReporter();
   
    TRACE_API virtual ~TraceReporter();
 
    const std::string& GetLabel() {
        return _label;
    }
 
 
    TRACE_API void Report(
        std::ostream &s,
        int iterationCount=1);
 
    TRACE_API void ReportTimes(std::ostream &s);
 
    TRACE_API void ReportChromeTracing(std::ostream &s);
 
 
    TRACE_API TraceAggregateNodePtr GetAggregateTreeRoot();
 
    TRACE_API TraceEventNodeRefPtr GetEventRoot();
 
    TRACE_API TraceEventTreeRefPtr GetEventTree();
 
 
    TRACE_API const CounterMap & GetCounters() const;
 
    TRACE_API int GetCounterIndex(const TfToken &key) const;
 
    TRACE_API bool AddCounter(const TfToken &key, int index, double totalValue);
 
 
    TRACE_API void UpdateTraceTrees();
    
    TRACE_API void ClearTree();
 
 
    TRACE_API void SetGroupByFunction(bool);
 
    TRACE_API bool GetGroupByFunction() const;
 
    TRACE_API void SetFoldRecursiveCalls(bool);
 
    TRACE_API bool GetFoldRecursiveCalls() const;
 
    TRACE_API void SetShouldAdjustForOverheadAndNoise(bool adjust);
 
    TRACE_API bool ShouldAdjustForOverheadAndNoise() const;
 
 
    TRACE_API static TraceAggregateNode::Id CreateValidEventId();
 
protected:
 
    TRACE_API TraceReporter(const std::string& label,
                   DataSourcePtr dataSource);
 
private:
    void _ProcessCollection(const TraceReporterBase::CollectionPtr&) override;
    void _RebuildEventAndAggregateTrees();
    void _PrintTimes(std::ostream &s);
 
private:
    std::string _label;
 
    bool _groupByFunction;
    bool _foldRecursiveCalls;
    bool _shouldAdjustForOverheadAndNoise;
 
    TraceAggregateTreeRefPtr _aggregateTree;
    TraceEventTreeRefPtr _eventTree;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_TRACE_REPORTER_H