diff --git a/include/phasar/Controller/AnalysisController.h b/include/phasar/Controller/AnalysisController.h
index 5ded47b64e..7b9e132c4b 100644
--- a/include/phasar/Controller/AnalysisController.h
+++ b/include/phasar/Controller/AnalysisController.h
@@ -13,159 +13,27 @@
 #include "phasar/AnalysisStrategy/Strategies.h"
 #include "phasar/Controller/AnalysisControllerEmitterOptions.h"
 #include "phasar/DataFlow/IfdsIde/IFDSIDESolverConfig.h"
-#include "phasar/DataFlow/IfdsIde/Solver/IDESolver.h"
-#include "phasar/DataFlow/IfdsIde/Solver/IFDSSolver.h"
-#include "phasar/DataFlow/IfdsIde/SolverResults.h"
-#include "phasar/DataFlow/Mono/Solver/InterMonoSolver.h"
-#include "phasar/DataFlow/Mono/Solver/IntraMonoSolver.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/SimpleAnalysisConstructor.h"
-#include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
-#include "phasar/Utils/EnumFlags.h"
-#include "phasar/Utils/IO.h"
-#include "phasar/Utils/Soundness.h"
-
-#include <set>
-#include <string>
-#include <vector>
 
+#include <filesystem>
 namespace psr {
 
 class AnalysisController {
-private:
-  HelperAnalyses &HA;
-  std::vector<DataFlowAnalysisType> DataFlowAnalyses;
-  std::vector<std::string> AnalysisConfigs;
-  std::vector<std::string> EntryPoints;
-  [[maybe_unused]] AnalysisStrategy Strategy;
-  AnalysisControllerEmitterOptions EmitterOptions =
-      AnalysisControllerEmitterOptions::None;
-  std::string ProjectID;
-  std::filesystem::path ResultDirectory;
-  IFDSIDESolverConfig SolverConfig;
-
-  ///
-  /// \brief The maximum length of the CallStrings used in the InterMonoSolver
-  ///
-  static const unsigned K = 3;
-
-  void executeDemandDriven();
-
-  void executeIncremental();
-
-  void executeModuleWise();
-
-  void executeVariational();
-
-  void executeWholeProgram();
-
-  void emitRequestedHelperAnalysisResults();
-
-  void executeIFDSUninitVar();
-  void executeIFDSConst();
-  void executeIFDSTaint();
-  void executeIFDSType();
-  void executeIFDSSolverTest();
-  void executeIFDSFieldSensTaint();
-  void executeIDEXTaint();
-  void executeIDEOpenSSLTS();
-  void executeIDECSTDIOTS();
-  void executeIDELinearConst();
-  void executeIDESolverTest();
-  void executeIDEIIA();
-  void executeIntraMonoFullConstant();
-  void executeIntraMonoSolverTest();
-  void executeInterMonoSolverTest();
-  void executeInterMonoTaint();
-
-  template <typename SolverTy, typename ProblemTy, typename... ArgTys>
-  void executeMonoAnalysis(ArgTys &&...Args) {
-    auto Problem =
-        createAnalysisProblem<ProblemTy>(HA, std::forward<ArgTys>(Args)...);
-    SolverTy Solver(Problem);
-    Solver.solve();
-    emitRequestedDataFlowResults(Solver);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIntraMonoAnalysis(ArgTys &&...Args) {
-    executeMonoAnalysis<IntraMonoSolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeInterMonoAnalysis(ArgTys &&...Args) {
-    executeMonoAnalysis<InterMonoSolver_P<ProblemTy, 3>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename SolverTy, typename ProblemTy, typename... ArgTys>
-  void executeIfdsIdeAnalysis(ArgTys &&...Args) {
-    auto Problem =
-        createAnalysisProblem<ProblemTy>(HA, std::forward<ArgTys>(Args)...);
-    SolverTy Solver(Problem, &HA.getICFG());
-    Solver.solve();
-    emitRequestedDataFlowResults(Solver);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIFDSAnalysis(ArgTys &&...Args) {
-    executeIfdsIdeAnalysis<IFDSSolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIDEAnalysis(ArgTys &&...Args) {
-    executeIfdsIdeAnalysis<IDESolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  LLVMTaintConfig makeTaintConfig();
-
-  template <typename T> void emitRequestedDataFlowResults(T &Solver) {
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS =
-                openFileStream(ResultDirectory.string() + "/psr-report.txt")) {
-          Solver.emitTextReport(*OFS);
-        }
-      } else {
-        Solver.emitTextReport(llvm::outs());
-      }
-    }
-    if (EmitterOptions &
-        AnalysisControllerEmitterOptions::EmitGraphicalReport) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS =
-                openFileStream(ResultDirectory.string() + "/psr-report.html")) {
-          Solver.emitGraphicalReport(*OFS);
-        }
-      } else {
-        Solver.emitGraphicalReport(llvm::outs());
-      }
-    }
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitRawResults) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS = openFileStream(ResultDirectory.string() +
-                                      "/psr-raw-results.txt")) {
-          Solver.dumpResults(*OFS);
-        }
-      } else {
-        Solver.dumpResults(llvm::outs());
-      }
-    }
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitESGAsDot) {
-      llvm::outs()
-          << "Front-end support for 'EmitESGAsDot' to be implemented\n";
-    }
-  }
-
 public:
+  struct ControllerData {
+    HelperAnalyses *HA{};
+    std::vector<DataFlowAnalysisType> DataFlowAnalyses;
+    std::vector<std::string> AnalysisConfigs;
+    std::vector<std::string> EntryPoints;
+    [[maybe_unused]] AnalysisStrategy Strategy;
+    AnalysisControllerEmitterOptions EmitterOptions =
+        AnalysisControllerEmitterOptions::None;
+    std::string ProjectID;
+    std::filesystem::path ResultDirectory;
+    IFDSIDESolverConfig SolverConfig{};
+  };
+
   explicit AnalysisController(
       HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
       std::vector<std::string> AnalysisConfigs,
@@ -175,21 +43,15 @@ class AnalysisController {
       std::string ProjectID = "default-phasar-project",
       std::string OutDirectory = "");
 
-  ~AnalysisController() = default;
-
-  AnalysisController(const AnalysisController &) = delete;
-  AnalysisController(AnalysisController &&) = delete;
-  AnalysisController &operator=(const AnalysisController &) = delete;
-  AnalysisController &operator=(const AnalysisController &&) = delete;
-
-  void executeAs(AnalysisStrategy Strategy);
-
   static constexpr bool
   needsToEmitPTA(AnalysisControllerEmitterOptions EmitterOptions) {
     return (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsDot) ||
            (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsJson) ||
            (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsText);
   }
+
+private:
+  ControllerData Data;
 };
 
 } // namespace psr
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index 72f33565ac..7f8e98df88 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -14,6 +14,8 @@
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/TypeName.h"
@@ -21,6 +23,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <atomic>
+#include <cstddef>
 #include <ostream>
 #include <tuple>
 #include <type_traits>
@@ -65,6 +68,12 @@ concept IsEdgeFunction = requires(const T &EF, const EdgeFunction<typename T::l_
 
 #endif
 
+enum class EdgeFunctionAllocationPolicy {
+  SmallObjectOptimized,
+  DefaultHeapAllocated,
+  CustomHeapAllocated,
+};
+
 class EdgeFunctionBase {
 public:
   template <typename ConcreteEF>
@@ -73,12 +82,9 @@ class EdgeFunctionBase {
                        alignof(ConcreteEF) <= alignof(void *) &&
                        std::is_trivially_copyable_v<ConcreteEF>;
 
+  using AllocationPolicy = EdgeFunctionAllocationPolicy;
+
 protected:
-  enum class AllocationPolicy {
-    SmallObjectOptimized,
-    DefaultHeapAllocated,
-    CustomHeapAllocated,
-  };
   struct RefCountedBase {
     mutable std::atomic_size_t Rc = 0;
   };
@@ -326,7 +332,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// details.
   ///
   [[nodiscard]] l_t computeTarget(ByConstRef<l_t> Source) const {
-    assert(!!*this && "computeTarget() called on nullptr!");
+    assert(isValid() && "computeTarget() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->computeTarget(EF, Source);
   }
 
@@ -357,8 +363,8 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// SecondEF.computeTarget(FirstEF.computeTarget(x)).
   [[nodiscard]] static EdgeFunction compose(const EdgeFunction &FirstEF,
                                             const EdgeFunction &SecondEF) {
-    assert(!!FirstEF && "compose() called on LHS nullptr!");
-    assert(!!SecondEF && "compose() called on RHS nullptr!");
+    assert(FirstEF.isValid() && "compose() called on LHS nullptr!");
+    assert(SecondEF.isValid() && "compose() called on RHS nullptr!");
     return FirstEF.VTAndHeapAlloc.getPointer()->compose(
         FirstEF.EF, SecondEF, FirstEF.VTAndHeapAlloc.getInt());
   }
@@ -398,12 +404,18 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// connected with the value-lattice on l_t
   [[nodiscard]] static EdgeFunction join(const EdgeFunction &FirstEF,
                                          const EdgeFunction &SecondEF) {
-    assert(!!FirstEF && "join() called on LHS nullptr!");
-    assert(!!SecondEF && "join() called on RHS nullptr!");
+    assert(FirstEF.isValid() && "join() called on LHS nullptr!");
+    assert(SecondEF.isValid() && "join() called on RHS nullptr!");
     return FirstEF.VTAndHeapAlloc.getPointer()->join(
         FirstEF.EF, SecondEF, FirstEF.VTAndHeapAlloc.getInt());
   }
 
+  [[nodiscard]] bool
+  referenceEquals(const EdgeFunction<L> &Other) const noexcept {
+    return VTAndHeapAlloc.getPointer() == Other.VTAndHeapAlloc.getPointer() &&
+           EF == Other.EF;
+  }
+
   /// Checks for equality of two edge functions. Equality requires exact
   /// type-equality and value-equality based on operator== of the concrete edge
   /// functions that are compared.
@@ -546,15 +558,17 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// Allows for better optimizations in compose and join and should be
   /// provided, whehever this knowledge is available.
   [[nodiscard]] bool isConstant() const noexcept {
-    assert(!!*this && "isConstant() called on nullptr!");
+    assert(isValid() && "isConstant() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->isConstant(EF);
   }
 
-  /// Performs a null-check. True, iff thie edge function is not null.
-  [[nodiscard]] explicit operator bool() const noexcept {
+  [[nodiscard]] bool isValid() const noexcept {
     return VTAndHeapAlloc.getOpaqueValue();
   }
 
+  /// Performs a null-check. True, iff thie edge function is not null.
+  [[nodiscard]] explicit operator bool() const noexcept { return isValid(); }
+
   /// Performs a runtime-typecheck. True, if the concrete type of the held edge
   /// function *exactly* equals ConcreteEF.
   ///
@@ -609,6 +623,10 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     return VTAndHeapAlloc.getInt() == AllocationPolicy::CustomHeapAllocated;
   }
 
+  [[nodiscard]] auto getAllocationPolicy() const noexcept {
+    return VTAndHeapAlloc.getInt();
+  }
+
   /// Gets an opaque identifier for this edge function. Only meant for
   /// comparisons of object-identity. Do not dereference!
   [[nodiscard]] const void *getOpaqueValue() const noexcept { return EF; }
@@ -630,6 +648,36 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     return static_cast<const CachedRefCounted<ConcreteEF> *>(EF)->Cache;
   }
 
+  [[nodiscard]] size_t getHashCode() const noexcept {
+    if (!VTAndHeapAlloc.getOpaqueValue()) {
+      return 0;
+    }
+
+    return VTAndHeapAlloc.getPointer()->getHashCode(
+        EF, VTAndHeapAlloc.getPointer());
+  }
+
+  [[nodiscard]] auto depth() const noexcept {
+    assert(isValid() && "depth() called on nullptr!");
+    return VTAndHeapAlloc.getPointer()->depth(EF);
+  }
+
+  friend size_t hash_value(const EdgeFunction &EF) noexcept { // NOLINT
+    return EF.getHashCode();
+  }
+
+  static EdgeFunction getEmptyKey() noexcept {
+    return EdgeFunction(nullptr,
+                        {llvm::DenseMapInfo<const VTable *>::getEmptyKey(),
+                         AllocationPolicy::SmallObjectOptimized});
+  }
+
+  static EdgeFunction getTombstoneKey() noexcept {
+    return EdgeFunction(nullptr,
+                        {llvm::DenseMapInfo<const VTable *>::getTombstoneKey(),
+                         AllocationPolicy::SmallObjectOptimized});
+  }
+
 private:
   struct VTable {
     // NOLINTBEGIN(readability-identifier-naming)
@@ -641,6 +689,8 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     void (*print)(const void *, llvm::raw_ostream &);
     bool (*isConstant)(const void *) noexcept;
     void (*destroy)(const void *, AllocationPolicy) noexcept;
+    size_t (*getHashCode)(const void *, const void *) noexcept;
+    size_t (*depth)(const void *) noexcept;
     // NOLINTEND(readability-identifier-naming)
   };
 
@@ -704,6 +754,23 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
           }
         }
       },
+      [](const void *EF, const void *VT) noexcept -> size_t {
+        if constexpr (is_std_hashable_v<ConcreteEF>) {
+          return std::hash<ConcreteEF>{}(*getPtr<ConcreteEF>(EF));
+        } else if constexpr (is_llvm_hashable_v<ConcreteEF>) {
+          using llvm::hash_value;
+          return hash_value(*getPtr<ConcreteEF>(EF));
+        } else {
+          return llvm::hash_combine(EF, VT);
+        }
+      },
+      [](const void *EF) noexcept -> size_t {
+        if constexpr (HasDepth<ConcreteEF>) {
+          return getPtr<ConcreteEF>(EF)->depth();
+        } else {
+          return 1;
+        }
+      },
   };
 
   // Utility ctor for (copy) construction. Increments the ref-count if
@@ -729,6 +796,32 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
 
 namespace llvm {
 
+template <typename L> struct DenseMapInfo<psr::EdgeFunction<L>> {
+  static inline auto getEmptyKey() noexcept {
+    return psr::EdgeFunction<L>::getEmptyKey();
+  }
+  static inline auto getTombstoneKey() noexcept {
+    return psr::EdgeFunction<L>::getTombstoneKey();
+  }
+  static inline auto getHashValue(const psr::EdgeFunction<L> &EF) noexcept {
+    return EF.getHashCode();
+  }
+  static inline auto isEqual(const psr::EdgeFunction<L> &EF1,
+                             const psr::EdgeFunction<L> &EF2) noexcept {
+    if (EF1.referenceEquals(EF2)) {
+      return true;
+    }
+    auto Empty = getEmptyKey();
+    auto Tombstone = getTombstoneKey();
+    if (EF1.referenceEquals(Empty) || EF2.referenceEquals(Empty) ||
+        EF1.referenceEquals(Tombstone) || EF2.referenceEquals(Tombstone)) {
+      return false;
+    }
+
+    return EF1 == EF2;
+  }
+};
+
 // LLVM is currently overhauling its casting system. Use the new variant once
 // possible!
 // Note: The new variant (With CastInfo) is not tested yet!
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
new file mode 100644
index 0000000000..448188b48b
--- /dev/null
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
@@ -0,0 +1,84 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
+#define PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <array>
+#include <cstddef>
+#include <numeric>
+
+namespace psr {
+enum class EdgeFunctionKind;
+enum class EdgeFunctionAllocationPolicy;
+
+namespace detail {
+struct EdgeFunctionStatsData {
+  static constexpr size_t NumEFKinds = 5;
+  static constexpr size_t NumAllocPolicies = 3;
+
+  std::array<size_t, NumEFKinds> UniqueEFCount{};
+  std::array<size_t, NumEFKinds> TotalEFCount{};
+  std::array<size_t, NumAllocPolicies> PerAllocCount{};
+  size_t MaxDepth{};
+  double AvgDepth{};
+  double AvgUniqueDepth{};
+
+  size_t TotalNumJF{};
+  size_t UniqueNumJF{};
+  size_t NumJFObjects{};
+  size_t MaxJFDepth{};
+  double AvgJFDepth{};
+  double AvgUniqueJFDepth{};
+  double AvgJFObjDepth{};
+  std::array<size_t, NumAllocPolicies> PerAllocJFCount{};
+};
+} // namespace detail
+
+class EdgeFunctionStats : public detail::EdgeFunctionStatsData {
+public:
+  [[nodiscard]] size_t getNumUniqueEFs() const noexcept {
+    return std::reduce(UniqueEFCount.begin(), UniqueEFCount.end());
+  }
+  [[nodiscard]] size_t getNumUniqueEFs(EdgeFunctionKind Kind) const noexcept {
+    assert(size_t(Kind) < NumEFKinds);
+    return UniqueEFCount[size_t(Kind)]; // NOLINT
+  }
+
+  [[nodiscard]] size_t getNumEFs() const noexcept {
+    return std::reduce(TotalEFCount.begin(), TotalEFCount.end());
+  }
+  [[nodiscard]] size_t getNumEFs(EdgeFunctionKind Kind) const noexcept {
+    assert(size_t(Kind) < NumEFKinds);
+    return TotalEFCount[size_t(Kind)]; // NOLINT
+  }
+
+  [[nodiscard]] size_t getNumEFsPerAllocationPolicy(
+      EdgeFunctionAllocationPolicy Policy) const noexcept {
+    assert(size_t(Policy) < NumAllocPolicies);
+    return PerAllocCount[size_t(Policy)]; // NOLINT
+  }
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                       const EdgeFunctionStats &S);
+
+private:
+  template <typename AnalysisDomainTy, typename Container>
+  friend class IDESolver;
+
+  constexpr EdgeFunctionStats(
+      const detail::EdgeFunctionStatsData &Data) noexcept
+      : detail::EdgeFunctionStatsData(Data) {}
+};
+} // namespace psr
+
+#endif // PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
index 018a7849fe..de9db609a6 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
@@ -13,6 +13,7 @@
 #include "phasar/DataFlow/IfdsIde/EdgeFunction.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/JoinLattice.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
@@ -265,12 +266,18 @@ template <typename L> struct EdgeFunctionComposer {
     return LHS.First == RHS.First && LHS.Second == RHS.Second;
   }
 
+  [[nodiscard]] size_t depth() const noexcept {
+    return First.depth() + Second.depth();
+  }
+
   // -- data members
 
   EdgeFunction<l_t> First{};
   EdgeFunction<l_t> Second{};
 };
 
+static_assert(HasDepth<EdgeFunctionComposer<int>>);
+
 template <typename L, uint8_t N> struct JoinEdgeFunction {
   using l_t = L;
   using JLattice = JoinLatticeTraits<L>;
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
index b9d89a88ea..637eaa083c 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
@@ -32,6 +32,10 @@ class Value;
 } // namespace llvm
 
 namespace psr {
+
+enum class EdgeFunctionKind { Normal, Call, Return, CallToReturn, Summary };
+static constexpr size_t EdgeFunctionKindCount = 5;
+
 template <typename KeyT> class DefaultMapKeyCompressor {
 public:
   using KeyType = KeyT;
@@ -603,6 +607,32 @@ class FlowEdgeFunctionCache {
     }
   }
 
+  template <typename Handler> void foreachCachedEdgeFunction(Handler Fn) const {
+    for (const auto &[Key, NormalFns] : NormalFunctionCache) {
+      for (const auto &[Set, EF] : NormalFns.EdgeFunctionMap) {
+        std::invoke(Fn, EF, EdgeFunctionKind::Normal);
+      }
+    }
+
+    for (const auto &[Key, EF] : CallEdgeFunctionCache) {
+      std::invoke(Fn, EF, EdgeFunctionKind::Call);
+    }
+
+    for (const auto &[Key, EF] : ReturnEdgeFunctionCache) {
+      std::invoke(Fn, EF, EdgeFunctionKind::Return);
+    }
+
+    for (const auto &[Key, CTRFns] : CallToRetEdgeFunctionCache) {
+      for (const auto &[Set, EF] : CTRFns) {
+        std::invoke(Fn, EF, EdgeFunctionKind::CallToReturn);
+      }
+    }
+
+    for (const auto &[Key, EF] : SummaryEdgeFunctionCache) {
+      std::invoke(Fn, EF, EdgeFunctionKind::Summary);
+    }
+  }
+
 private:
   inline EdgeFuncInstKey createEdgeFunctionInstKey(n_t Lhs, n_t Rhs) {
     uint64_t Val = 0;
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index eb2c323c3a..3274ced1a8 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -20,6 +20,7 @@
 #include "phasar/Config/Configuration.h"
 #include "phasar/DB/ProjectIRDBBase.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunction.h"
+#include "phasar/DataFlow/IfdsIde/EdgeFunctionStats.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunctions.h"
 #include "phasar/DataFlow/IfdsIde/FlowFunctions.h"
@@ -33,6 +34,7 @@
 #include "phasar/DataFlow/IfdsIde/Solver/PathEdge.h"
 #include "phasar/DataFlow/IfdsIde/SolverResults.h"
 #include "phasar/Domain/AnalysisDomain.h"
+#include "phasar/Utils/Average.h"
 #include "phasar/Utils/DOTGraph.h"
 #include "phasar/Utils/JoinLattice.h"
 #include "phasar/Utils/Logger.h"
@@ -40,6 +42,7 @@
 #include "phasar/Utils/Table.h"
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -256,6 +259,81 @@ class IDESolver
                                               std::move(ZeroValue));
   }
 
+  [[nodiscard]] EdgeFunctionStats getEdgeFunctionStatistics() const {
+    detail::EdgeFunctionStatsData Stats{};
+
+    // Cached Edge Functions
+    {
+      std::array<llvm::DenseSet<EdgeFunction<l_t>>, EdgeFunctionKindCount>
+          UniqueEFs{};
+      Sampler DepthSampler{};
+      Sampler UniqueDepthSampler{};
+      // TODO: Cache EFs
+      CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
+          [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
+            auto Depth = EF.depth();
+            DepthSampler.addSample(Depth);
+            if (Depth > Stats.MaxDepth) {
+              Stats.MaxDepth = Depth;
+            }
+
+            if (UniqueEFs[size_t(Kind)].insert(std::move(EF)).second) {
+              UniqueDepthSampler.addSample(Depth);
+            }
+            Stats.TotalEFCount[size_t(Kind)]++;
+            Stats.PerAllocCount[size_t(EF.getAllocationPolicy())]++;
+          });
+
+      size_t TotalUniqueNumEF = 0;
+      for (size_t I = 0, End = UniqueEFs.size(); I != End; ++I) {
+        Stats.UniqueEFCount[I] = UniqueEFs[I].size(); // NOLINT
+        TotalUniqueNumEF += UniqueEFs[I].size();
+      }
+
+      Stats.AvgDepth = DepthSampler.getAverage();
+      Stats.AvgUniqueDepth = UniqueDepthSampler.getAverage();
+    }
+
+    // Jump Functions
+    {
+      llvm::DenseSet<EdgeFunction<l_t>> UniqueJumpFns;
+      llvm::DenseSet<const void *> AllocatedJumpFns;
+      Sampler DepthSampler{};
+      Sampler UniqueDepthSampler{};
+      Sampler AllocDepthSampler{};
+
+      JumpFn->foreachEdgeFunction([&](EdgeFunction<l_t> JF) {
+        ++Stats.TotalNumJF;
+        auto Depth = JF.depth();
+        DepthSampler.addSample(Depth);
+        if (Depth > Stats.MaxJFDepth) {
+          Stats.MaxJFDepth = Depth;
+        }
+
+        if (AllocatedJumpFns.insert(JF.getOpaqueValue()).second) {
+          AllocDepthSampler.addSample(Depth);
+        }
+
+        Stats.PerAllocJFCount[size_t(JF.getAllocationPolicy())]++;
+
+        if (UniqueJumpFns.insert(std::move(JF)).second) {
+          UniqueDepthSampler.addSample(Depth);
+        }
+      });
+
+      Stats.UniqueNumJF = UniqueJumpFns.size();
+      Stats.NumJFObjects = AllocatedJumpFns.size();
+      Stats.AvgJFDepth = DepthSampler.getAverage();
+      Stats.AvgUniqueJFDepth = UniqueDepthSampler.getAverage();
+      Stats.AvgJFObjDepth = AllocDepthSampler.getAverage();
+    }
+    return Stats;
+  }
+
+  void printEdgeFunctionStatistics(llvm::raw_ostream &OS = llvm::outs()) const {
+    OS << getEdgeFunctionStatistics() << '\n';
+  }
+
 protected:
   /// Lines 13-20 of the algorithm; processing a call site in the caller's
   /// context.
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h b/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
index 0a9bcb3274..85a80fe604 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
@@ -18,6 +18,7 @@
 #define PHASAR_DATAFLOW_IFDSIDE_SOLVER_JUMPFUNCTIONS_H
 
 #include "phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h"
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Table.h"
 
@@ -157,6 +158,18 @@ template <typename AnalysisDomainTy, typename Container> class JumpFunctions {
     return NonEmptyLookupByTargetNode[Target];
   }
 
+  template <typename HandlerFn>
+  void foreachEdgeFunction(HandlerFn Handler) const {
+    NonEmptyForwardLookup.foreachCell(
+        [Handler = std::move(Handler)](ByConstRef<d_t> /*Row*/,
+                                       ByConstRef<n_t> /*Col*/,
+                                       const auto &TargetFactAndEF) {
+          for (const auto &[TargetFact, EF] : TargetFactAndEF) {
+            std::invoke(Handler, EF);
+          }
+        });
+  }
+
   /**
    * Removes a jump function. The source statement is implicit.
    * @see PathEdge
diff --git a/include/phasar/Utils/Average.h b/include/phasar/Utils/Average.h
new file mode 100644
index 0000000000..c6e54f0901
--- /dev/null
+++ b/include/phasar/Utils/Average.h
@@ -0,0 +1,33 @@
+/******************************************************************************
+ * Copyright (c) 2024 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_AVERAGE_H
+#define PHASAR_UTILS_AVERAGE_H
+
+#include <cstddef>
+
+namespace psr {
+
+struct Sampler {
+  size_t Count{};
+  double Curr{};
+
+  constexpr void addSample(size_t Sample) noexcept {
+    Curr += (double(Sample) - Curr) / double(++Count);
+  }
+
+  [[nodiscard]] constexpr double getAverage() const noexcept { return Curr; }
+  [[nodiscard]] constexpr size_t getNumSamples() const noexcept {
+    return Count;
+  }
+};
+
+} // namespace psr
+
+#endif // PHASAR_UTILS_AVERAGE_H
diff --git a/include/phasar/Utils/Timer.h b/include/phasar/Utils/Timer.h
new file mode 100644
index 0000000000..f485aa0cba
--- /dev/null
+++ b/include/phasar/Utils/Timer.h
@@ -0,0 +1,43 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_TIMER_H
+#define PHASAR_UTILS_TIMER_H
+
+#include "llvm/ADT/FunctionExtras.h"
+
+#include <chrono>
+
+namespace psr {
+class Timer {
+public:
+  Timer(llvm::unique_function<void(std::chrono::nanoseconds)>
+            WithElapsed) noexcept
+      : WithElapsed(std::move(WithElapsed)),
+        Start(std::chrono::steady_clock::now()) {}
+
+  Timer(Timer &&) noexcept = default;
+  Timer &operator=(Timer &&) noexcept = default;
+  Timer(const Timer &) = delete;
+  Timer &operator=(const Timer &) = delete;
+
+  ~Timer() {
+    if (WithElapsed) {
+      auto End = std::chrono::steady_clock::now();
+      WithElapsed(End - Start);
+    }
+  }
+
+private:
+  llvm::unique_function<void(std::chrono::nanoseconds)> WithElapsed;
+  std::chrono::steady_clock::time_point Start;
+};
+} // namespace psr
+
+#endif // PHASAR_UTILS_TIMER_H
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index e954dd14e6..f4c6736f28 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -112,6 +112,10 @@ struct is_llvm_hashable : std::false_type {}; // NOLINT
 template <typename T>
 struct is_llvm_hashable<T, decltype(hash_value(std::declval<T>()))> // NOLINT
     : std::true_type {};
+template <typename T>
+struct is_llvm_hashable<T,
+                        decltype(llvm::hash_value(std::declval<T>()))> // NOLINT
+    : std::true_type {};
 
 template <template <typename> typename Base, typename Derived>
 class template_arg {
@@ -154,6 +158,11 @@ struct AreEqualityComparable<T, U,
                              decltype(std::declval<T>() == std::declval<U>())>
     : std::true_type {};
 
+template <typename T, typename = size_t> struct HasDepth : std::false_type {};
+template <typename T>
+struct HasDepth<T, decltype(std::declval<const T &>().depth())>
+    : std::true_type {};
+
 template <typename Var, typename T> struct variant_idx;
 template <typename... Ts, typename T>
 struct variant_idx<std::variant<Ts...>, T>
@@ -223,6 +232,9 @@ constexpr bool is_crtp_base_of_v = // NOLINT
 template <typename T>
 static inline constexpr bool HasIsConstant = detail::HasIsConstant<T>::value;
 
+template <typename T>
+static inline constexpr bool HasDepth = detail::HasDepth<T>::value;
+
 template <typename T>
 static inline constexpr bool IsEqualityComparable =
     detail::IsEqualityComparable<T>::value;
diff --git a/lib/Controller/AnalysisController.cpp b/lib/Controller/AnalysisController.cpp
index 1341319a08..4266e4cfc5 100644
--- a/lib/Controller/AnalysisController.cpp
+++ b/lib/Controller/AnalysisController.cpp
@@ -9,136 +9,18 @@
 
 #include "phasar/Controller/AnalysisController.h"
 
-#include "phasar/AnalysisStrategy/Strategies.h"
-#include "phasar/Controller/AnalysisControllerEmitterOptions.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/HelperAnalyses.h"
 #include "phasar/PhasarLLVM/Passes/GeneralStatisticsAnalysis.h"
-#include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/Utils/NlohmannLogging.h"
-#include "phasar/Utils/Utilities.h"
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/ErrorHandling.h"
-
-#include <cassert>
-#include <filesystem>
-#include <functional>
-#include <set>
-#include <utility>
+#include "AnalysisControllerInternal.h"
 
 namespace psr {
 
-AnalysisController::AnalysisController(
-    HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
-    std::vector<std::string> AnalysisConfigs,
-    std::vector<std::string> EntryPoints, AnalysisStrategy Strategy,
-    AnalysisControllerEmitterOptions EmitterOptions,
-    IFDSIDESolverConfig SolverConfig, std::string ProjectID,
-    std::string OutDirectory)
-    : HA(HA), DataFlowAnalyses(std::move(DataFlowAnalyses)),
-      AnalysisConfigs(std::move(AnalysisConfigs)),
-      EntryPoints(std::move(EntryPoints)), Strategy(Strategy),
-      EmitterOptions(EmitterOptions), ProjectID(std::move(ProjectID)),
-      ResultDirectory(std::move(OutDirectory)), SolverConfig(SolverConfig) {
-  if (!ResultDirectory.empty()) {
-    // create directory for results
-    ResultDirectory /= this->ProjectID + "-" + createTimeStamp();
-    std::filesystem::create_directory(ResultDirectory);
-  }
-  emitRequestedHelperAnalysisResults();
-  executeAs(Strategy);
-}
-
-void AnalysisController::executeAs(AnalysisStrategy Strategy) {
-  switch (Strategy) {
-  case AnalysisStrategy::None:
-    return;
-  case AnalysisStrategy::DemandDriven:
-  case AnalysisStrategy::Incremental:
-  case AnalysisStrategy::ModuleWise:
-  case AnalysisStrategy::Variational:
-    llvm::report_fatal_error("AnalysisStrategy not supported, yet!");
-    return;
-  case AnalysisStrategy::WholeProgram:
-    executeWholeProgram();
-    return;
-  }
-  llvm_unreachable(
-      "All AnalysisStrategy variants should be handled in the switch above!");
-}
-
-void AnalysisController::executeDemandDriven() {}
-
-void AnalysisController::executeIncremental() {}
-
-void AnalysisController::executeModuleWise() {}
-
-void AnalysisController::executeVariational() {}
-
-void AnalysisController::executeWholeProgram() {
-  for (auto DataFlowAnalysis : DataFlowAnalyses) {
-    switch (DataFlowAnalysis) {
-    case DataFlowAnalysisType::None:
-      continue;
-    case DataFlowAnalysisType::IFDSUninitializedVariables:
-      executeIFDSUninitVar();
-      continue;
-    case DataFlowAnalysisType::IFDSConstAnalysis:
-      executeIFDSConst();
-      continue;
-    case DataFlowAnalysisType::IFDSTaintAnalysis:
-      executeIFDSTaint();
-      continue;
-    case DataFlowAnalysisType::IDEExtendedTaintAnalysis:
-      executeIDEXTaint();
-      continue;
-    case DataFlowAnalysisType::IDEOpenSSLTypeStateAnalysis:
-      executeIDEOpenSSLTS();
-      continue;
-    case DataFlowAnalysisType::IDECSTDIOTypeStateAnalysis:
-      executeIDECSTDIOTS();
-      continue;
-    case DataFlowAnalysisType::IFDSTypeAnalysis:
-      executeIFDSType();
-      continue;
-    case DataFlowAnalysisType::IFDSSolverTest:
-      executeIFDSSolverTest();
-      continue;
-    case DataFlowAnalysisType::IFDSFieldSensTaintAnalysis:
-      executeIFDSFieldSensTaint();
-      continue;
-    case DataFlowAnalysisType::IDELinearConstantAnalysis:
-      executeIDELinearConst();
-      continue;
-    case DataFlowAnalysisType::IDESolverTest:
-      executeIDESolverTest();
-      continue;
-    case DataFlowAnalysisType::IDEInstInteractionAnalysis:
-      executeIDEIIA();
-      continue;
-    case DataFlowAnalysisType::IntraMonoFullConstantPropagation:
-      executeIntraMonoFullConstant();
-      continue;
-    case DataFlowAnalysisType::IntraMonoSolverTest:
-      executeIntraMonoSolverTest();
-      continue;
-    case DataFlowAnalysisType::InterMonoSolverTest:
-      executeInterMonoSolverTest();
-      continue;
-    case DataFlowAnalysisType::InterMonoTaintAnalysis:
-      executeInterMonoTaint();
-      continue;
-    }
-
-    llvm_unreachable("All possible DataFlowAnalysisType variants should be "
-                     "handled in the switch above!");
-  }
-}
-
-void AnalysisController::emitRequestedHelperAnalysisResults() {
-  auto WithResultFileOrStdout = [this](const auto &FileName, auto Callback) {
+static void
+emitRequestedHelperAnalysisResults(AnalysisController::ControllerData &Data) {
+  auto WithResultFileOrStdout = [&ResultDirectory = Data.ResultDirectory](
+                                    const auto &FileName, auto Callback) {
     if (!ResultDirectory.empty()) {
       if (auto OFS = openFileStream(ResultDirectory.string() + FileName)) {
         Callback(*OFS);
@@ -148,46 +30,49 @@ void AnalysisController::emitRequestedHelperAnalysisResults() {
     }
   };
 
+  auto EmitterOptions = Data.EmitterOptions;
+  auto &HA = *Data.HA;
+
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitIR) {
-    WithResultFileOrStdout("/psr-preprocess-ir.ll", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-preprocess-ir.ll", [&HA](auto &OS) {
       HA.getProjectIRDB().emitPreprocessedIR(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsText) {
     WithResultFileOrStdout(
-        "/psr-th.txt", [this](auto &OS) { HA.getTypeHierarchy().print(OS); });
+        "/psr-th.txt", [&HA](auto &OS) { HA.getTypeHierarchy().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsDot) {
-    WithResultFileOrStdout("/psr-th.dot", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-th.dot", [&HA](auto &OS) {
       HA.getTypeHierarchy().printAsDot(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsJson) {
-    WithResultFileOrStdout("/psr-th.json", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-th.json", [&HA](auto &OS) {
       HA.getTypeHierarchy().printAsJson(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsText) {
     WithResultFileOrStdout("/psr-pta.txt",
-                           [this](auto &OS) { HA.getAliasInfo().print(OS); });
+                           [&HA](auto &OS) { HA.getAliasInfo().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsDot) {
     WithResultFileOrStdout("/psr-pta.dot",
-                           [this](auto &OS) { HA.getAliasInfo().print(OS); });
+                           [&HA](auto &OS) { HA.getAliasInfo().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsJson) {
-    WithResultFileOrStdout("/psr-pta.json", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-pta.json", [&HA](auto &OS) {
       HA.getAliasInfo().printAsJson(OS);
     });
   }
 
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitCGAsDot) {
     WithResultFileOrStdout("/psr-cg.txt",
-                           [this](auto &OS) { HA.getICFG().print(OS); });
+                           [&HA](auto &OS) { HA.getICFG().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitCGAsJson) {
-    WithResultFileOrStdout(
-        "/psr-cg.json", [this](auto &OS) { OS << HA.getICFG().getAsJson(); });
+    WithResultFileOrStdout("/psr-cg.json",
+                           [&HA](auto &OS) { OS << HA.getICFG().getAsJson(); });
   }
 
   if (EmitterOptions &
@@ -211,13 +96,144 @@ void AnalysisController::emitRequestedHelperAnalysisResults() {
   }
 }
 
-LLVMTaintConfig AnalysisController::makeTaintConfig() {
+static void executeDemandDriven(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'demand-driven' not supported, yet!");
+}
+static void executeIncremental(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'incremental' not supported, yet!");
+}
+static void executeModuleWise(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'module-wise' not supported, yet!");
+}
+static void executeVariational(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'variational' not supported, yet!");
+}
+
+static void executeWholeProgram(AnalysisController::ControllerData &Data) {
+  for (auto DataFlowAnalysis : Data.DataFlowAnalyses) {
+    using namespace controller;
+    switch (DataFlowAnalysis) {
+    case DataFlowAnalysisType::None:
+      continue;
+    case DataFlowAnalysisType::IFDSUninitializedVariables:
+      executeIFDSUninitVar(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSConstAnalysis:
+      executeIFDSConst(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSTaintAnalysis:
+      executeIFDSTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDEExtendedTaintAnalysis:
+      executeIDEXTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDEOpenSSLTypeStateAnalysis:
+      executeIDEOpenSSLTS(Data);
+      continue;
+    case DataFlowAnalysisType::IDECSTDIOTypeStateAnalysis:
+      executeIDECSTDIOTS(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSTypeAnalysis:
+      executeIFDSType(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSSolverTest:
+      executeIFDSSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSFieldSensTaintAnalysis:
+      executeIFDSFieldSensTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDELinearConstantAnalysis:
+      executeIDELinearConst(Data);
+      continue;
+    case DataFlowAnalysisType::IDESolverTest:
+      executeIDESolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::IDEInstInteractionAnalysis:
+      executeIDEIIA(Data);
+      continue;
+    case DataFlowAnalysisType::IntraMonoFullConstantPropagation:
+      executeIntraMonoFullConstant(Data);
+      continue;
+    case DataFlowAnalysisType::IntraMonoSolverTest:
+      executeIntraMonoSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::InterMonoSolverTest:
+      executeInterMonoSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::InterMonoTaintAnalysis:
+      executeInterMonoTaint(Data);
+      continue;
+    }
+
+    llvm_unreachable("All possible DataFlowAnalysisType variants should be "
+                     "handled in the switch above!");
+  }
+}
+
+static void executeAs(AnalysisController::ControllerData &Data,
+                      AnalysisStrategy Strategy) {
+  switch (Strategy) {
+  case AnalysisStrategy::None:
+    return;
+  case AnalysisStrategy::DemandDriven:
+    executeDemandDriven(Data);
+    return;
+  case AnalysisStrategy::Incremental:
+    executeIncremental(Data);
+    return;
+  case AnalysisStrategy::ModuleWise:
+    executeModuleWise(Data);
+    return;
+  case AnalysisStrategy::Variational:
+    executeVariational(Data);
+    return;
+  case AnalysisStrategy::WholeProgram:
+    executeWholeProgram(Data);
+    return;
+  }
+  llvm_unreachable(
+      "All AnalysisStrategy variants should be handled in the switch above!");
+}
+
+AnalysisController::AnalysisController(
+    HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
+    std::vector<std::string> AnalysisConfigs,
+    std::vector<std::string> EntryPoints, AnalysisStrategy Strategy,
+    AnalysisControllerEmitterOptions EmitterOptions,
+    IFDSIDESolverConfig SolverConfig, std::string ProjectID,
+    std::string OutDirectory)
+    : Data{
+          &HA,
+          std::move(DataFlowAnalyses),
+          std::move(AnalysisConfigs),
+          std::move(EntryPoints),
+          Strategy,
+          EmitterOptions,
+          std::move(ProjectID),
+          std::move(OutDirectory),
+          SolverConfig,
+      } {
+  if (!Data.ResultDirectory.empty()) {
+    // create directory for results
+    Data.ResultDirectory /= Data.ProjectID + "-" + createTimeStamp();
+    std::filesystem::create_directory(Data.ResultDirectory);
+  }
+  emitRequestedHelperAnalysisResults(Data);
+  executeAs(Data, Strategy);
+}
+
+LLVMTaintConfig
+controller::makeTaintConfig(AnalysisController::ControllerData &Data) {
   std::string AnalysisConfigPath =
-      !AnalysisConfigs.empty() ? AnalysisConfigs[0] : "";
+      !Data.AnalysisConfigs.empty() ? Data.AnalysisConfigs[0] : "";
   return !AnalysisConfigPath.empty()
-             ? LLVMTaintConfig(HA.getProjectIRDB(),
+             ? LLVMTaintConfig(Data.HA->getProjectIRDB(),
                                parseTaintConfig(AnalysisConfigPath))
-             : LLVMTaintConfig(HA.getProjectIRDB());
+             : LLVMTaintConfig(Data.HA->getProjectIRDB());
 }
 
 } // namespace psr
diff --git a/lib/Controller/AnalysisControllerInternal.h b/lib/Controller/AnalysisControllerInternal.h
new file mode 100644
index 0000000000..8a736e3a11
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternal.h
@@ -0,0 +1,125 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
+
+#include "phasar/Controller/AnalysisController.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/SimpleAnalysisConstructor.h"
+#include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
+#include "phasar/Utils/ChronoUtils.h"
+#include "phasar/Utils/IO.h"
+#include "phasar/Utils/Timer.h"
+
+#include "llvm/Support/Compiler.h"
+
+namespace psr {
+template <typename T, typename U> class IDESolver;
+} // namespace psr
+
+namespace psr::controller {
+
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSUninitVar(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSConst(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSType(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSFieldSensTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEXTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEOpenSSLTS(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDECSTDIOTS(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDELinearConst(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDESolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEIIA(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIntraMonoFullConstant(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIntraMonoSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeInterMonoSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeInterMonoTaint(AnalysisController::ControllerData &Data);
+
+///
+/// \brief The maximum length of the CallStrings used in the InterMonoSolver
+///
+static constexpr unsigned K = 3;
+
+[[nodiscard]] LLVM_LIBRARY_VISIBILITY LLVMTaintConfig
+makeTaintConfig(AnalysisController::ControllerData &Data);
+
+template <typename T>
+static void statsEmitter(llvm::raw_ostream & /*OS*/, const T & /*Solver*/) {}
+template <typename T, typename U>
+static void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver);
+
+template <typename T>
+static void
+emitRequestedDataFlowResults(AnalysisController::ControllerData &Data,
+                             T &Solver) {
+  auto EmitterOptions = Data.EmitterOptions;
+  const auto &ResultDirectory = Data.ResultDirectory;
+
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS =
+              openFileStream(ResultDirectory.string() + "/psr-report.txt")) {
+        Solver.emitTextReport(*OFS);
+      }
+    } else {
+      Solver.emitTextReport(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitGraphicalReport) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS =
+              openFileStream(ResultDirectory.string() + "/psr-report.html")) {
+        Solver.emitGraphicalReport(*OFS);
+      }
+    } else {
+      Solver.emitGraphicalReport(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitRawResults) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS = openFileStream(ResultDirectory.string() +
+                                    "/psr-raw-results.txt")) {
+        Solver.dumpResults(*OFS);
+      }
+    } else {
+      Solver.dumpResults(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitESGAsDot) {
+    llvm::outs() << "Front-end support for 'EmitESGAsDot' to be implemented\n";
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+
+    statsEmitter(llvm::outs(), Solver);
+  }
+}
+
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
diff --git a/lib/Controller/AnalysisControllerInternalIDE.h b/lib/Controller/AnalysisControllerInternalIDE.h
new file mode 100644
index 0000000000..fa758bbb68
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternalIDE.h
@@ -0,0 +1,62 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALIDE_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALIDE_H
+
+#include "phasar/DataFlow/IfdsIde/Solver/IDESolver.h"
+#include "phasar/DataFlow/IfdsIde/Solver/IFDSSolver.h"
+
+#include "AnalysisControllerInternal.h"
+
+namespace psr::controller {
+
+template <typename T, typename U>
+static void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver) {
+  OS << "\nEdgeFunction Statistics:\n";
+  Solver.printEdgeFunctionStatistics(OS);
+}
+
+template <typename SolverTy, typename ProblemTy, typename... ArgTys>
+static void executeIfdsIdeAnalysis(AnalysisController::ControllerData &Data,
+                                   ArgTys &&...Args) {
+  auto Problem =
+      createAnalysisProblem<ProblemTy>(*Data.HA, std::forward<ArgTys>(Args)...);
+  SolverTy Solver(Problem, &Data.HA->getICFG());
+  {
+    std::optional<Timer> MeasureTime;
+    if (Data.EmitterOptions &
+        AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+      MeasureTime.emplace([](auto Elapsed) {
+        llvm::outs() << "Elapsed: " << hms{Elapsed} << '\n';
+      });
+    }
+
+    Solver.solve();
+  }
+  emitRequestedDataFlowResults(Data, Solver);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIFDSAnalysis(AnalysisController::ControllerData &Data,
+                                ArgTys &&...Args) {
+  executeIfdsIdeAnalysis<IFDSSolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIDEAnalysis(AnalysisController::ControllerData &Data,
+                               ArgTys &&...Args) {
+  executeIfdsIdeAnalysis<IDESolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
diff --git a/lib/Controller/AnalysisControllerInternalMono.h b/lib/Controller/AnalysisControllerInternalMono.h
new file mode 100644
index 0000000000..e688789318
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternalMono.h
@@ -0,0 +1,45 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
+
+#include "phasar/DataFlow/Mono/Solver/InterMonoSolver.h"
+#include "phasar/DataFlow/Mono/Solver/IntraMonoSolver.h"
+
+#include "AnalysisControllerInternal.h"
+
+namespace psr::controller {
+
+template <typename SolverTy, typename ProblemTy, typename... ArgTys>
+static void executeMonoAnalysis(AnalysisController::ControllerData &Data,
+                                ArgTys &&...Args) {
+  auto Problem =
+      createAnalysisProblem<ProblemTy>(*Data.HA, std::forward<ArgTys>(Args)...);
+  SolverTy Solver(Problem);
+  Solver.solve();
+  emitRequestedDataFlowResults(Data, Solver);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIntraMonoAnalysis(AnalysisController::ControllerData &Data,
+                                     ArgTys &&...Args) {
+  executeMonoAnalysis<IntraMonoSolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeInterMonoAnalysis(AnalysisController::ControllerData &Data,
+                                     ArgTys &&...Args) {
+  executeMonoAnalysis<InterMonoSolver_P<ProblemTy, K>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
diff --git a/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp b/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
index 59bd165343..f6c268ae8b 100644
--- a/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
+++ b/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
@@ -7,16 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/TypeStateDescriptions/CSTDFILEIOTypeStateDescription.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDECSTDIOTS() {
+using namespace psr;
+
+void controller::executeIDECSTDIOTS(AnalysisController::ControllerData &Data) {
   CSTDFILEIOTypeStateDescription TSDesc;
   executeIDEAnalysis<IDETypeStateAnalysis<CSTDFILEIOTypeStateDescription>>(
-      &TSDesc, EntryPoints);
+      Data, &TSDesc, Data.EntryPoints);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDEIIA.cpp b/lib/Controller/AnalysisControllerXIDEIIA.cpp
index 17b053f16b..e44f08422e 100644
--- a/lib/Controller/AnalysisControllerXIDEIIA.cpp
+++ b/lib/Controller/AnalysisControllerXIDEIIA.cpp
@@ -7,16 +7,17 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEInstInteractionAnalysis.h"
 
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEIIA() {
+using namespace psr;
+
+void controller::executeIDEIIA(AnalysisController::ControllerData &Data) {
   // use Phasar's instruction ids as testing labels
   auto Generator =
       [](std::variant<const llvm::Instruction *, const llvm::GlobalVariable *>
@@ -38,7 +39,6 @@ void AnalysisController::executeIDEIIA() {
         Current);
   };
 
-  executeIDEAnalysis<IDEInstInteractionAnalysis>(EntryPoints, Generator);
+  executeIDEAnalysis<IDEInstInteractionAnalysis>(Data, Data.EntryPoints,
+                                                 Generator);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDELinearConst.cpp b/lib/Controller/AnalysisControllerXIDELinearConst.cpp
index 7f62100865..1e794814f1 100644
--- a/lib/Controller/AnalysisControllerXIDELinearConst.cpp
+++ b/lib/Controller/AnalysisControllerXIDELinearConst.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDELinearConst() {
-  executeIDEAnalysis<IDELinearConstantAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDELinearConst(
+    AnalysisController::ControllerData &Data) {
+  executeIDEAnalysis<IDELinearConstantAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp b/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
index 6c6dba3b45..f45029770f 100644
--- a/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
+++ b/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
@@ -7,16 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/TypeStateDescriptions/OpenSSLEVPKDFDescription.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEOpenSSLTS() {
+using namespace psr;
+
+void controller::executeIDEOpenSSLTS(AnalysisController::ControllerData &Data) {
   OpenSSLEVPKDFDescription TSDesc;
   executeIDEAnalysis<IDETypeStateAnalysis<OpenSSLEVPKDFDescription>>(
-      &TSDesc, EntryPoints);
+      Data, &TSDesc, Data.EntryPoints);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDESolverTest.cpp b/lib/Controller/AnalysisControllerXIDESolverTest.cpp
index 5c840dc502..719207aa39 100644
--- a/lib/Controller/AnalysisControllerXIDESolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIDESolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDESolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDESolverTest() {
-  executeIDEAnalysis<IDESolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDESolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIDEAnalysis<IDESolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIDEXTaint.cpp b/lib/Controller/AnalysisControllerXIDEXTaint.cpp
index 8813c0ff77..8929394573 100644
--- a/lib/Controller/AnalysisControllerXIDEXTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIDEXTaint.cpp
@@ -7,14 +7,14 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEExtendedTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEXTaint() {
-  auto Config = makeTaintConfig();
-  executeIDEAnalysis<IDEExtendedTaintAnalysis<>>(Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDEXTaint(AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIDEAnalysis<IDEExtendedTaintAnalysis<>>(Data, Config,
+                                                 Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSConst.cpp b/lib/Controller/AnalysisControllerXIFDSConst.cpp
index 0dfc6c724c..0393c29509 100644
--- a/lib/Controller/AnalysisControllerXIFDSConst.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSConst.cpp
@@ -7,13 +7,12 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSConstAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSConst() {
-  executeIFDSAnalysis<IFDSConstAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSConst(AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSConstAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp b/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
index 0042d94006..6e50cd4f19 100644
--- a/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
@@ -7,14 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSFieldSensTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSFieldSensTaint() {
-  auto Config = makeTaintConfig();
-  executeIFDSAnalysis<IFDSFieldSensTaintAnalysis>(&Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSFieldSensTaint(
+    AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIFDSAnalysis<IFDSFieldSensTaintAnalysis>(Data, &Config,
+                                                  Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp b/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
index ff45656e25..08f8c26898 100644
--- a/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSSolverTest() {
-  executeIFDSAnalysis<IFDSSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSSolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSTaint.cpp b/lib/Controller/AnalysisControllerXIFDSTaint.cpp
index 49fe79caa0..a94abca60d 100644
--- a/lib/Controller/AnalysisControllerXIFDSTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSTaint.cpp
@@ -7,14 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSTaint() {
-  auto Config = makeTaintConfig();
-  executeIFDSAnalysis<IFDSTaintAnalysis>(&Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSTaint(AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIFDSAnalysis<IFDSTaintAnalysis>(Data, &Config, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSType.cpp b/lib/Controller/AnalysisControllerXIFDSType.cpp
index 2c90d8536a..e5a56d531c 100644
--- a/lib/Controller/AnalysisControllerXIFDSType.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSType.cpp
@@ -7,13 +7,12 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTypeAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSType() {
-  executeIFDSAnalysis<IFDSTypeAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSType(AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSTypeAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSUninit.cpp b/lib/Controller/AnalysisControllerXIFDSUninit.cpp
index 1e1772f761..db66cfef1d 100644
--- a/lib/Controller/AnalysisControllerXIFDSUninit.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSUninit.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSUninitializedVariables.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSUninitVar() {
-  executeIFDSAnalysis<IFDSUninitializedVariables>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSUninitVar(
+    AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSUninitializedVariables>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp b/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
index f6de335f44..17ad61168d 100644
--- a/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeInterMonoSolverTest() {
-  executeInterMonoAnalysis<InterMonoSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeInterMonoSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeInterMonoAnalysis<InterMonoSolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXInterMonoTaint.cpp b/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
index 2f9a6cbea0..cc24440e1e 100644
--- a/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
+++ b/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
@@ -7,14 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeInterMonoTaint() {
-  auto Config = makeTaintConfig();
-  executeInterMonoAnalysis<InterMonoTaintAnalysis>(Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeInterMonoTaint(
+    AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeInterMonoAnalysis<InterMonoTaintAnalysis>(Data, Config,
+                                                   Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp b/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
index 50013234f8..65a95b338b 100644
--- a/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
+++ b/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
@@ -7,13 +7,14 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoFullConstantPropagation.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeIntraMonoFullConstant() {
-  executeIntraMonoAnalysis<IntraMonoFullConstantPropagation>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIntraMonoFullConstant(
+    AnalysisController::ControllerData &Data) {
+  executeIntraMonoAnalysis<IntraMonoFullConstantPropagation>(Data,
+                                                             Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp b/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
index c3b61cf7ec..557d5899d6 100644
--- a/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeIntraMonoSolverTest() {
-  executeIntraMonoAnalysis<IntraMonoSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIntraMonoSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIntraMonoAnalysis<IntraMonoSolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
index a8aa6e8240..1836e070fc 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
@@ -22,8 +22,10 @@
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
+#include "phasar/Utils/TypeTraits.h"
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/AbstractCallSite.h"
 #include "llvm/IR/Constants.h"
@@ -66,7 +68,20 @@ struct LCAEdgeFunctionComposer : EdgeFunctionComposer<l_t> {
   }
 };
 
-using GenConstant = ConstantEdgeFunction<l_t>;
+auto hash_value(const LCAEdgeFunctionComposer &EF) noexcept {
+  return llvm::hash_combine(EF.First, EF.Second);
+}
+
+static_assert(is_llvm_hashable_v<LCAEdgeFunctionComposer>);
+
+struct GenConstant : ConstantEdgeFunction<l_t> {};
+
+llvm::hash_code hash_value(const GenConstant &EF) noexcept {
+  return llvm::hash_value(EF.Value);
+}
+
+using TTT = decltype(hash_value(std::declval<GenConstant>()));
+static_assert(is_llvm_hashable_v<GenConstant>);
 
 /**
  * The following binary operations are computed:
@@ -220,7 +235,6 @@ struct BinOp {
     }
 
     // TODO: Optimize Binop::composeWith(BinOp)
-
     return LCAEdgeFunctionComposer{This, SecondFunction};
   }
 
@@ -253,6 +267,13 @@ struct BinOp {
     return OS;
   }
 };
+
+auto hash_value(const BinOp &EF) noexcept {
+  return llvm::hash_combine(EF.Op, EF.Lop, EF.Rop, EF.CurrNode);
+}
+
+static_assert(is_llvm_hashable_v<BinOp>);
+
 } // namespace lca
 
 IDELinearConstantAnalysis::IDELinearConstantAnalysis(
diff --git a/lib/Utils/EdgeFunctionStats.cpp b/lib/Utils/EdgeFunctionStats.cpp
new file mode 100644
index 0000000000..56b85bc501
--- /dev/null
+++ b/lib/Utils/EdgeFunctionStats.cpp
@@ -0,0 +1,49 @@
+#include "phasar/DataFlow/IfdsIde/EdgeFunctionStats.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Format.h"
+
+llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
+                                   const EdgeFunctionStats &S) {
+  static constexpr auto EFKind = {"Normal", "Call", "Return", "CallToReturn",
+                                  "Summary"};
+  static constexpr auto AllocKind = {
+      "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
+
+  OS << "Cached Edge Functions:\n";
+
+  for (const auto &[UEF, Count, EFK] :
+       llvm::zip(S.UniqueEFCount, S.TotalEFCount, EFKind)) {
+    OS << "  Kind: " << EFK << ":\n";
+    OS << "    Total #EdgeFunctions:\t" << Count << '\n';
+    OS << "    Unique EdgeFunctions:\t" << UEF << '\n';
+  }
+
+  OS << "  AllocationPolicy:\n";
+  for (auto [Count, Kind] : llvm::zip(S.PerAllocCount, AllocKind)) {
+    OS << "    " << Kind << ":\t" << Count << '\n';
+  }
+
+  OS << "  Depth:\n";
+  OS << "    Max Depth:\t\t\t" << S.MaxDepth << '\n';
+  OS << "    Avg Depth:\t\t\t" << llvm::format("%g\n", S.AvgDepth);
+  OS << "    Avg Unique Depth:\t\t" << llvm::format("%g\n", S.AvgUniqueDepth);
+
+  OS << "Jump Functions:\n";
+  OS << "  Total #JumpFunctions:\t\t" << S.TotalNumJF << '\n';
+  OS << "  Unique JumpFunctions:\t\t" << S.UniqueNumJF << '\n';
+  OS << "  JumpFunctions Objects:\t" << S.NumJFObjects << '\n';
+
+  OS << "  AllocationPolicy:\n";
+  for (auto [Count, Kind] : llvm::zip(S.PerAllocJFCount, AllocKind)) {
+    OS << "    " << Kind << ":\t" << Count << '\n';
+  }
+
+  OS << "  Depth:\n";
+  OS << "    Max Depth:\t\t\t" << S.MaxJFDepth << '\n';
+  OS << "    Avg Depth:\t\t\t" << llvm::format("%g\n", S.AvgJFDepth);
+  OS << "    Avg Unique Depth:\t\t" << llvm::format("%g\n", S.AvgUniqueJFDepth);
+  OS << "    Avg JF Object Depth:\t" << llvm::format("%g\n", S.AvgJFObjDepth);
+
+  return OS;
+}