AliasAnalysisPrecisionEvaluator.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Håvard Krogstie <krogstie.havard@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_OPT_ALIAS_ANALYSES_ALIASANALYSISPRECISIONEVALUATOR_HPP
#define JLM_LLVM_OPT_ALIAS_ANALYSES_ALIASANALYSISPRECISIONEVALUATOR_HPP
 
#include <jlm/llvm/opt/alias-analyses/AliasAnalysis.hpp>
#include <jlm/rvsdg/lambda.hpp>
#include <jlm/rvsdg/RvsdgModule.hpp>
#include <jlm/util/GraphWriter.hpp>
#include <jlm/util/Statistics.hpp>
 
#include <unordered_map>
 
namespace jlm::util
{
class GraphWriter;
}
 
namespace jlm::llvm::aa
{
 
class AliasAnalysisPrecisionEvaluator final
{
  class PrecisionStatistics;
 
public:
  AliasAnalysisPrecisionEvaluator();
 
  ~AliasAnalysisPrecisionEvaluator() noexcept;
 
  void
  SetLoadsConsideredClobbers(bool loadsConsideredClobbers) noexcept
  {
    LoadsConsideredClobbers_ = loadsConsideredClobbers;
  }
 
  [[nodiscard]] bool
  AreLoadsConsideredClobbers() const noexcept
  {
    return LoadsConsideredClobbers_;
  }
 
  void
  SetDeduplicatePointers(bool deduplicatePointers) noexcept
  {
    DeduplicatePointers_ = deduplicatePointers;
  }
 
  [[nodiscard]] bool
  IsDeduplicatingPointers() const noexcept
  {
    return DeduplicatePointers_;
  }
 
  void
  SetAliasingGraphEnabled(bool aliasingGraphEnabled) noexcept
  {
    AliasingGraphEnabled_ = aliasingGraphEnabled;
  }
 
  [[nodiscard]] bool
  IsAliasingGraphEnabled() const noexcept
  {
    return AliasingGraphEnabled_;
  }
 
  void
  SetPerFunctionOutputEnabled(bool perFunctionOutputEnabled) noexcept
  {
    PerFunctionOutputEnabled_ = perFunctionOutputEnabled;
  }
 
  [[nodiscard]] bool
  IsPerFunctionOutputEnabled() const noexcept
  {
    return PerFunctionOutputEnabled_;
  }
 
  void
  EvaluateAliasAnalysisClient(
      const rvsdg::RvsdgModule & rvsdgModule,
      AliasAnalysis & aliasAnalysis,
      util::StatisticsCollector & statisticsCollector);
 
private:
  void
  EvaluateAllFunctions(const rvsdg::Region & region, AliasAnalysis & aliasAnalysis);
 
  void
  EvaluateFunction(const rvsdg::LambdaNode & function, AliasAnalysis & aliasAnalysis);
 
  void
  CollectPointersFromRegion(const rvsdg::Region & region);
 
  void
  CollectPointersFromSimpleNode(const rvsdg::SimpleNode & node);
 
  void
  CollectPointersFromStructuralNode(const rvsdg::StructuralNode & node);
 
  void
  CollectPointer(const rvsdg::Output * value, size_t size, bool isClobber);
 
  void
  NormalizePointerValues();
 
  void
  AggregateDuplicates();
 
  void
  CalculateResults(
      std::optional<util::FilePath> perFunctionOutput,
      PrecisionStatistics & statistics) const;
 
  void
  AddToAliasingGraph(
      const rvsdg::Output & p1,
      size_t s1,
      const rvsdg::Output & p2,
      size_t s2,
      AliasAnalysis::AliasQueryResponse response);
 
  // Alias analysis precision info for a set of pointer usages, such as in a function
  struct PrecisionInfo
  {
    struct ClobberInfo
    {
      // A single ClobberInfo can represent multiple identical clobbers.
      // The multiplier should be applied to all the alias query response counters below,
      // and when calculating the average of all clobbers, the multiplier is the weight.
      uint64_t Multiplier = 1;
 
      uint64_t NumNoAlias = 0;
      uint64_t NumMayAlias = 0;
      uint64_t NumMustAlias = 0;
    };
 
    std::vector<ClobberInfo> ClobberOperations;
 
    uint64_t NumClobberOperations = 0;
 
    uint64_t NumOperations = 0;
  };
 
  struct AggregatedClobberInfos
  {
    uint64_t NumClobberOperations = 0;
 
    // Statistics about the average ClobberInfo. Sum to 1
    double ClobberAverageNoAlias = 0.0;
    double ClobberAverageMayAlias = 0.0;
    double ClobberAverageMustAlias = 0.0;
 
    // Total number of alias query responses
    uint64_t TotalNoAlias = 0;
    uint64_t TotalMayAlias = 0;
    uint64_t TotalMustAlias = 0;
  };
 
  [[nodiscard]] static AggregatedClobberInfos
  AggregateClobberInfos(const std::vector<PrecisionInfo::ClobberInfo> & clobberInfos);
 
  static void
  PrintAggregatedClobberInfos(const AggregatedClobberInfos & clobberInfos, std::ostream & out);
 
  struct Context
  {
    // Output dot graph, only used if dumping a graph of alias analysis-response edges is enabled
    util::graph::Graph * AliasingGraph_ = {};
 
    // Precision info per function in the evaluated module
    std::unordered_map<const rvsdg::LambdaNode *, PrecisionInfo> PerFunctionPrecision;
 
    std::vector<std::tuple<const rvsdg::Output *, size_t, bool, size_t>> PointerOperations;
  };
 
  // Whether to consider loads as clobbers
  bool LoadsConsideredClobbers_ = false;
 
  // Whether to deduplicate pointers
  bool DeduplicatePointers_ = false;
 
  // Whether to create an aliasing graph and write it to a file
  bool AliasingGraphEnabled_ = false;
 
  // Whether to create a file containing aliasing statistics per function
  bool PerFunctionOutputEnabled_ = false;
 
  // Data used during evaluation
  Context Context_;
};
 
}
 
#endif // JLM_LLVM_OPT_ALIAS_ANALYSES_ALIASANALYSISPRECISIONEVALUATOR_HPP