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