executionStats.h

 
#ifndef EXECUTION_STATS_H
#define EXECUTION_STATS_H
 
#include <map>
 
#include "tpg/instrumented/tpgExecutionEngineInstrumented.h"
#include "tpg/tpgGraph.h"
 
namespace TPG {
 
    struct TraceStats
    {
        const std::vector<const TPG::TPGVertex*> trace;
 
        const uint64_t nbEvaluatedTeams;
        const uint64_t nbEvaluatedPrograms;
        const uint64_t nbExecutedLines;
        const std::map<uint64_t, uint64_t> nbExecutionPerInstruction;
    };
 
    class ExecutionStats
    {
 
      private:
        /* Average results */
 
        double avgEvaluatedTeams = 0.0;
 
        double avgEvaluatedPrograms = 0.0;
 
        double avgExecutedLines = 0.0;
 
        std::map<size_t, double> avgNbExecutionPerInstruction;
 
        /* Analyzed Traces */
 
        std::vector<TraceStats> inferenceTracesStats;
 
        /* Distributions */
 
        std::map<size_t, size_t> distribEvaluatedTeams;
 
        std::map<size_t, size_t> distribEvaluatedPrograms;
 
        std::map<size_t, size_t> distribExecutedLines;
 
        std::map<size_t, std::map<size_t, size_t>>
            distribNbExecutionPerInstruction;
 
        std::map<const TPG::TPGVertex*, size_t> distribUsedVertices;
 
        const TPGGraph* lastAnalyzedGraph = nullptr;
 
      protected:
        static void analyzeProgram(
            std::map<uint64_t, uint64_t>& instructionCounts,
            const Program::Program& program);
 
      public:
        ExecutionStats() = default;
 
        virtual ~ExecutionStats() = default;
 
        void analyzeInstrumentedGraph(const TPGGraph* graph);
 
        void analyzeInferenceTrace(const std::vector<const TPGVertex*>& trace);
 
        void analyzeExecution(const TPG::TPGExecutionEngineInstrumented& tee,
                              const TPGGraph* graph);
 
        double getAvgEvaluatedTeams() const;
 
        double getAvgEvaluatedPrograms() const;
 
        double getAvgExecutedLines() const;
 
        const std::map<size_t, double>& getAvgNbExecutionPerInstruction() const;
 
        const std::vector<TraceStats>& getInferenceTracesStats() const;
 
        const std::map<size_t, size_t>& getDistribEvaluatedTeams() const;
 
        const std::map<size_t, size_t>& getDistribEvaluatedPrograms() const;
 
        const std::map<size_t, size_t>& getDistribExecutedLines() const;
 
        const std::map<size_t, std::map<size_t, size_t>>&
        getDistribNbExecutionPerInstruction() const;
 
        const std::map<const TPG::TPGVertex*, size_t>& getDistribUsedVertices()
            const;
 
        void clearInferenceTracesStats();
 
        void writeStatsToJson(const char* filePath,
                              bool noIndent = false) const;
    };
 
} // namespace TPG
 
#endif // EXECUTION_STATS_H