Statistics.hpp

Go to the documentation of this file.

/*
 * Copyright 2017 Nico Reißmann <nico.reissmann@gmail.com>
 * Copyright 2024 Håvard Krogstie <krogstie.havard@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_UTIL_STATISTICS_HPP
#define JLM_UTIL_STATISTICS_HPP
 
#include <jlm/util/file.hpp>
#include <jlm/util/HashSet.hpp>
#include <jlm/util/strfmt.hpp>
#include <jlm/util/time.hpp>
 
#include <cstdint>
#include <list>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace jlm::util
{
 
class Statistics
{
public:
  enum class Id
  {
    FirstEnumValue, // must always be the first enum value, used for iteration
 
    Aggregation,
    AgnosticModRefSummarizer,
    AliasAnalysisPrecisionEvaluation,
    AndersenAnalysis,
    Annotation,
    CommonNodeElimination,
    ControlFlowRecovery,
    DataNodeToDelta,
    DeadNodeElimination,
    FunctionInlining,
    IfConversion,
    InvariantValueRedirection,
    JlmToRvsdgConversion,
    LoopUnrolling,
    LoopUnswitching,
    MemoryStateEncoder,
    PullNodes,
    PushNodes,
    ReduceNodes,
    RegionAwareModRefSummarizer,
    RvsdgConstruction,
    RvsdgDestruction,
    RvsdgOptimization,
    RvsdgTreePrinter,
    ScalarEvolution,
 
    LastEnumValue // must always be the last enum value, used for iteration
  };
 
  using Measurement = std::variant<std::string, int64_t, uint64_t, double>;
  // Lists are used instead of vectors to give stable references to members
  using MeasurementList = std::list<std::pair<std::string, Measurement>>;
  using TimerList = std::list<std::pair<std::string, util::Timer>>;
 
  virtual ~Statistics();
 
  Statistics(const Statistics::Id & statisticsId, util::FilePath sourceFile)
      : StatisticsId_(statisticsId),
        SourceFile_(std::move(sourceFile))
  {}
 
  [[nodiscard]] Statistics::Id
  GetId() const noexcept
  {
    return StatisticsId_;
  }
 
  [[nodiscard]] std::string_view
  GetName() const;
 
  [[nodiscard]] const util::FilePath &
  GetSourceFile() const;
 
  [[nodiscard]] std::string
  Serialize(char fieldSeparator, char nameValueSeparator) const;
 
  [[nodiscard]] bool
  HasMeasurement(const std::string & name) const noexcept;
 
  [[nodiscard]] const Measurement &
  GetMeasurement(const std::string & name) const;
 
  template<typename T>
  [[nodiscard]] const T &
  GetMeasurementValue(const std::string & name) const
  {
    const auto & measurement = GetMeasurement(name);
    return std::get<T>(measurement);
  }
 
  [[nodiscard]] IteratorRange<MeasurementList::const_iterator>
  GetMeasurements() const;
 
  [[nodiscard]] bool
  HasTimer(const std::string & name) const noexcept;
 
  [[nodiscard]] size_t
  GetTimerElapsedNanoseconds(const std::string & name) const
  {
    return GetTimer(name).ns();
  }
 
  [[nodiscard]] IteratorRange<TimerList::const_iterator>
  GetTimers() const;
 
protected:
  template<typename T>
  void
  AddMeasurement(std::string name, T value)
  {
    JLM_ASSERT(!HasMeasurement(name));
    Measurements_.emplace_back(std::make_pair(std::move(name), std::move(value)));
  }
 
  util::Timer &
  AddTimer(std::string name);
 
  [[nodiscard]] util::Timer &
  GetTimer(const std::string & name);
 
  [[nodiscard]] const util::Timer &
  GetTimer(const std::string & name) const;
 
  struct Label
  {
    static inline const char * FunctionNameLabel_ = "Function";
 
    static inline const char * NumCfgNodes = "#CfgNodes";
 
    static inline const char * NumThreeAddressCodes = "#ThreeAddressCodes";
 
    static inline const char * NumRvsdgNodes = "#RvsdgNodes";
    static inline const char * NumRvsdgNodesBefore = "#RvsdgNodesBefore";
    static inline const char * NumRvsdgNodesAfter = "#RvsdgNodesAfter";
 
    static inline const char * NumRvsdgInputsBefore = "#RvsdgInputsBefore";
    static inline const char * NumRvsdgInputsAfter = "#RvsdgInputsAfter";
 
    inline static const char * NumPointsToGraphNodes = "#PointsToGraphNodes";
    inline static const char * NumPointsToGraphAllocaNodes = "#PointsToGraphAllocaNodes";
    inline static const char * NumPointsToGraphDeltaNodes = "#PointsToGraphDeltaNodes";
    inline static const char * NumPointsToGraphImportNodes = "#PointsToGraphImportNodes";
    inline static const char * NumPointsToGraphLambdaNodes = "#PointsToGraphLambdaNodes";
    inline static const char * NumPointsToGraphMallocNodes = "#PointsToGraphMallocNodes";
    inline static const char * NumPointsToGraphMemoryNodes = "#PointsToGraphMemoryNodes";
    inline static const char * NumPointsToGraphRegisterNodes = "#PointsToGraphRegisterNodes";
    inline static const char * NumPointsToGraphExternallyAvailableNodes =
        "#PointsToGraphExternallyAvailableNodes";
    inline static const char * NumPointsToGraphNodesTargetsAllExternallyAvailable =
        "#PointsToGraphNodesTargetsAllExternallyAvailable";
 
    inline static const char * NumPointsToGraphExplicitEdges = "#PointsToGraphExplicitEdges";
    inline static const char * NumPointsToGraphEdges = "#PointsToGraphEdges";
 
    inline static const char * NumLoopVariablesTotal = "#LoopVariablesTotal";
    inline static const char * NumTotalRecurrences = "#TotalRecurrences";
    inline static const char * NumConstantRecurrences = "#ConstantRecurrences";
    inline static const char * NumFirstOrderRecurrences = "#FirstOrderRecurrences";
    inline static const char * NumSecondOrderRecurrences = "#SecondOrderRecurrences";
    inline static const char * NumThirdOrderRecurrences = "#ThirdOrderRecurrences";
 
    static inline const char * Timer = "Time";
  };
 
private:
  Statistics::Id StatisticsId_;
  util::FilePath SourceFile_;
 
  MeasurementList Measurements_;
  TimerList Timers_;
};
 
class StatisticsCollectorSettings final
{
public:
  StatisticsCollectorSettings()
      : Directory_("."),
        ModuleName_("")
  {}
 
  explicit StatisticsCollectorSettings(HashSet<Statistics::Id> demandedStatistics)
      : DemandedStatistics_(std::move(demandedStatistics)),
        Directory_("."),
        ModuleName_("")
  {}
 
  StatisticsCollectorSettings(
      HashSet<Statistics::Id> demandedStatistics,
      std::optional<FilePath> directory,
      std::string moduleName)
      : DemandedStatistics_(std::move(demandedStatistics)),
        Directory_(std::move(directory)),
        ModuleName_(std::move(moduleName))
  {}
 
  void
  SetDemandedStatistics(HashSet<Statistics::Id> demandedStatistics)
  {
    DemandedStatistics_ = std::move(demandedStatistics);
  }
 
  [[nodiscard]] size_t
  NumDemandedStatistics() const noexcept
  {
    return DemandedStatistics_.Size();
  }
 
  [[nodiscard]] const HashSet<Statistics::Id> &
  GetDemandedStatistics() const noexcept
  {
    return DemandedStatistics_;
  }
 
  [[nodiscard]] bool
  isDemanded(Statistics::Id id) const noexcept
  {
    return DemandedStatistics_.Contains(id);
  }
 
  [[nodiscard]] bool
  HasOutputDirectory() const noexcept
  {
    return Directory_.has_value();
  }
 
  [[nodiscard]] const FilePath &
  GetOutputDirectory() const noexcept
  {
    JLM_ASSERT(Directory_.has_value());
    return Directory_.value();
  }
 
  [[nodiscard]] const FilePath &
  GetOrCreateOutputDirectory() const noexcept
  {
    JLM_ASSERT(Directory_.has_value());
    Directory_->CreateDirectory();
    return Directory_.value();
  }
 
  void
  SetOutputDirectory(FilePath directory)
  {
    Directory_ = std::move(directory);
  }
 
  [[nodiscard]] const std::string &
  GetModuleName() const noexcept
  {
    return ModuleName_;
  }
 
  void
  SetModuleName(std::string moduleName)
  {
    ModuleName_ = std::move(moduleName);
  }
 
  [[nodiscard]] const std::string &
  GetUniqueString() const noexcept
  {
    return UniqueString_;
  }
 
  void
  SetUniqueString(std::string uniqueString)
  {
    UniqueString_ = std::move(uniqueString);
  }
 
private:
  HashSet<Statistics::Id> DemandedStatistics_;
  std::optional<FilePath> Directory_;
  std::string ModuleName_;
  std::string UniqueString_ = CreateRandomAlphanumericString(6);
};
 
class StatisticsCollector final
{
  class StatisticsIterator final
  {
  public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = const Statistics *;
    using difference_type = std::ptrdiff_t;
    using pointer = const Statistics **;
    using reference = const Statistics *&;
 
  private:
    friend StatisticsCollector;
 
    explicit StatisticsIterator(const std::vector<std::unique_ptr<Statistics>>::const_iterator & it)
        : it_(it)
    {}
 
  public:
    [[nodiscard]] const Statistics *
    GetStatistics() const noexcept
    {
      return it_->get();
    }
 
    const Statistics &
    operator*() const
    {
      JLM_ASSERT(GetStatistics() != nullptr);
      return *GetStatistics();
    }
 
    const Statistics *
    operator->() const
    {
      return GetStatistics();
    }
 
    StatisticsIterator &
    operator++()
    {
      ++it_;
      return *this;
    }
 
    StatisticsIterator
    operator++(int)
    {
      StatisticsIterator tmp = *this;
      ++*this;
      return tmp;
    }
 
    bool
    operator==(const StatisticsIterator & other) const
    {
      return it_ == other.it_;
    }
 
    bool
    operator!=(const StatisticsIterator & other) const
    {
      return !operator==(other);
    }
 
  private:
    std::vector<std::unique_ptr<Statistics>>::const_iterator it_;
  };
 
public:
  using StatisticsRange = IteratorRange<StatisticsIterator>;
 
  StatisticsCollector()
  {}
 
  explicit StatisticsCollector(StatisticsCollectorSettings settings)
      : Settings_(std::move(settings))
  {}
 
  const StatisticsCollectorSettings &
  GetSettings() const noexcept
  {
    return Settings_;
  }
 
  StatisticsRange
  CollectedStatistics() const noexcept
  {
    return { StatisticsIterator(CollectedStatistics_.begin()),
             StatisticsIterator(CollectedStatistics_.end()) };
  }
 
  [[nodiscard]] size_t
  NumCollectedStatistics() const noexcept
  {
    return CollectedStatistics_.size();
  }
 
  [[nodiscard]] bool
  IsDemanded(Statistics::Id id) const noexcept
  {
    return GetSettings().isDemanded(id);
  }
 
  [[nodiscard]] bool
  IsDemanded(const Statistics & statistics) const noexcept
  {
    return IsDemanded(statistics.GetId());
  }
 
  void
  CollectDemandedStatistics(std::unique_ptr<Statistics> statistics)
  {
    if (IsDemanded(*statistics))
      CollectedStatistics_.emplace_back(std::move(statistics));
  }
 
  [[nodiscard]] std::unique_ptr<Statistics>
  releaseStatistic(Statistics::Id id)
  {
    auto it = CollectedStatistics_.end();
    while (it != CollectedStatistics_.begin())
    {
      it--;
      if (it->get()->GetId() == id)
      {
        auto result = std::move(*it);
        CollectedStatistics_.erase(it);
        return result;
      }
    }
    throw std::out_of_range("No Statistics with the given id has been collected");
  }
 
  void
  PrintStatistics();
 
  [[nodiscard]] File
  createOutputFile(std::string fileNameSuffix, bool includeCount = false);
 
private:
  StatisticsCollectorSettings Settings_;
  std::vector<std::unique_ptr<Statistics>> CollectedStatistics_;
 
  // Counter used to give unique file names to output files that share suffix
  std::unordered_map<std::string, size_t> OutputFileCounter_;
};
 
}
 
#endif