PredicateCorrelation.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_OPT_PREDICATECORRELATION_HPP
#define JLM_LLVM_OPT_PREDICATECORRELATION_HPP
 
#include <jlm/rvsdg/gamma.hpp>
#include <jlm/rvsdg/theta.hpp>
#include <jlm/rvsdg/Transformation.hpp>
 
#include <optional>
#include <variant>
#include <vector>
 
namespace jlm
{
 
namespace rvsdg
{
class Region;
class ThetaNode;
}
 
namespace util
{
class StatisticsCollector;
}
}
 
namespace jlm::llvm
{
 
enum class CorrelationType
{
  ControlConstantCorrelation,
 
  MatchConstantCorrelation,
 
  MatchCorrelation,
};
 
class GammaGammaPredicateCorrelation final
{
public:
  struct MatchCorrelationData
  {
    rvsdg::Node * matchNode{};
  };
 
  using CorrelationData = std::variant<MatchCorrelationData>;
 
private:
  GammaGammaPredicateCorrelation(
      const CorrelationType type,
      rvsdg::GammaNode & gammaNode1,
      rvsdg::GammaNode & gammaNode2,
      CorrelationData correlationData)
      : type_(type),
        gammaNode1_(gammaNode1),
        gammaNode2_(gammaNode2),
        correlationData_(std::move(correlationData))
  {}
 
public:
  [[nodiscard]] CorrelationType
  type() const noexcept
  {
    return type_;
  }
 
  [[nodiscard]] rvsdg::GammaNode &
  gammaNode1() const noexcept
  {
    return gammaNode1_;
  }
 
  [[nodiscard]] rvsdg::GammaNode &
  gammaNode2() const noexcept
  {
    return gammaNode2_;
  }
 
  [[nodiscard]] const CorrelationData &
  correlationData() const noexcept
  {
    return correlationData_;
  }
 
  static std::unique_ptr<GammaGammaPredicateCorrelation>
  CreateMatchCorrelation(
      rvsdg::GammaNode & gammaNode1,
      rvsdg::GammaNode & gammaNode2,
      MatchCorrelationData correlationData)
  {
    return std::unique_ptr<GammaGammaPredicateCorrelation>(new GammaGammaPredicateCorrelation(
        CorrelationType::MatchCorrelation,
        gammaNode1,
        gammaNode2,
        std::move(correlationData)));
  }
 
private:
  CorrelationType type_;
  rvsdg::GammaNode & gammaNode1_;
  rvsdg::GammaNode & gammaNode2_;
  CorrelationData correlationData_;
};
 
std::optional<std::unique_ptr<GammaGammaPredicateCorrelation>>
computeGammaGammaPredicateCorrelation(rvsdg::GammaNode & gammaNode);
 
class ThetaGammaPredicateCorrelation final
{
public:
  using ControlConstantCorrelationData = std::vector<uint64_t>;
 
  struct MatchConstantCorrelationData
  {
    rvsdg::Node * matchNode{};
    std::vector<uint64_t> alternatives{};
  };
 
  struct MatchCorrelationData
  {
    rvsdg::Node * matchNode{};
  };
 
  using CorrelationData = std::
      variant<ControlConstantCorrelationData, MatchConstantCorrelationData, MatchCorrelationData>;
 
private:
  ThetaGammaPredicateCorrelation(
      const CorrelationType type,
      rvsdg::ThetaNode & thetaNode,
      rvsdg::GammaNode & gammaNode,
      CorrelationData correlationData)
      : type_(type),
        thetaNode_(thetaNode),
        gammaNode_(gammaNode),
        data_(std::move(correlationData))
  {}
 
public:
  [[nodiscard]] CorrelationType
  type() const noexcept
  {
    return type_;
  }
 
  [[nodiscard]] rvsdg::ThetaNode &
  thetaNode() const noexcept
  {
    return thetaNode_;
  }
 
  [[nodiscard]] rvsdg::GammaNode &
  gammaNode() const noexcept
  {
    return gammaNode_;
  }
 
  [[nodiscard]] const CorrelationData &
  data() const noexcept
  {
    return data_;
  }
 
  static std::unique_ptr<ThetaGammaPredicateCorrelation>
  CreateControlConstantCorrelation(
      rvsdg::ThetaNode & thetaNode,
      rvsdg::GammaNode & gammaNode,
      ControlConstantCorrelationData data)
  {
    return std::unique_ptr<ThetaGammaPredicateCorrelation>(new ThetaGammaPredicateCorrelation(
        CorrelationType::ControlConstantCorrelation,
        thetaNode,
        gammaNode,
        std::move(data)));
  }
 
  static std::unique_ptr<ThetaGammaPredicateCorrelation>
  CreateMatchConstantCorrelation(
      rvsdg::ThetaNode & thetaNode,
      rvsdg::GammaNode & gammaNode,
      MatchConstantCorrelationData data)
  {
    return std::unique_ptr<ThetaGammaPredicateCorrelation>(new ThetaGammaPredicateCorrelation(
        CorrelationType::MatchConstantCorrelation,
        thetaNode,
        gammaNode,
        std::move(data)));
  }
 
  static std::unique_ptr<ThetaGammaPredicateCorrelation>
  CreateMatchCorrelation(
      rvsdg::ThetaNode & thetaNode,
      rvsdg::GammaNode & gammaNode,
      MatchCorrelationData data)
  {
    return std::unique_ptr<ThetaGammaPredicateCorrelation>(new ThetaGammaPredicateCorrelation(
        CorrelationType::MatchCorrelation,
        thetaNode,
        gammaNode,
        std::move(data)));
  }
 
private:
  CorrelationType type_;
  rvsdg::ThetaNode & thetaNode_;
  rvsdg::GammaNode & gammaNode_;
  CorrelationData data_{};
};
 
std::optional<std::unique_ptr<ThetaGammaPredicateCorrelation>>
computeThetaGammaPredicateCorrelation(rvsdg::ThetaNode & thetaNode);
 
typedef struct
{
  rvsdg::Region * repetitionSubregion;
  rvsdg::Region * exitSubregion;
} GammaSubregionRoles;
 
std::optional<GammaSubregionRoles>
determineGammaSubregionRoles(const ThetaGammaPredicateCorrelation & correlation);
 
class PredicateCorrelation final : public rvsdg::Transformation
{
public:
  ~PredicateCorrelation() noexcept override;
 
  PredicateCorrelation()
      : Transformation("PredicateCorrelation")
  {}
 
  PredicateCorrelation(const PredicateCorrelation &) = delete;
 
  PredicateCorrelation &
  operator=(const PredicateCorrelation &) = delete;
 
  void
  Run(rvsdg::RvsdgModule & rvsdgModule, util::StatisticsCollector & statisticsCollector) override;
 
private:
  static void
  correlatePredicatesInRegion(rvsdg::Region & region);
 
  static void
  correlatePredicatesInTheta(rvsdg::ThetaNode & thetaNode);
 
  static bool
  handleControlConstantCorrelation(const ThetaGammaPredicateCorrelation & correlation);
 
  static bool
  handleMatchConstantCorrelation(const ThetaGammaPredicateCorrelation & correlation);
};
 
}
 
#endif