Introduce ReachabilityAnalysis to lazily compute what nodes are reachable

Use it in resource sharing pass.

PiperOrigin-RevId: 826393302

Author: angelomatni1

xls/passes/BUILD

@@ -1065,6 +1065,7 @@ xls_pass(
         ":pass_base",
         ":post_dominator_analysis",
         ":query_engine",
+        ":reachability_analysis",
         "//xls/common/status:ret_check",
         "//xls/common/status:status_macros",
         "//xls/estimators/area_model:area_estimator",
@@ -1083,8 +1084,6 @@ xls_pass(
         "@com_google_absl//absl/random",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/types:span",
-        "@com_google_ortools//ortools/graph",
-        "@com_google_ortools//ortools/graph:cliques",
         "@cppitertools",
     ],
 )
@@ -1507,6 +1506,34 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "reachability_analysis",
+    srcs = ["reachability_analysis.cc"],
+    hdrs = ["reachability_analysis.h"],
+    deps = [
+        ":lazy_node_data",
+        "//xls/ir",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/types:span",
+    ],
+)
+
+cc_test(
+    name = "reachability_analysis_test",
+    srcs = ["reachability_analysis_test.cc"],
+    deps = [
+        ":reachability_analysis",
+        "//xls/common:xls_gunit_main",
+        "//xls/common/status:matchers",
+        "//xls/ir",
+        "//xls/ir:function_builder",
+        "//xls/ir:ir_test_base",
+        "//xls/ir:op",
+        "@googletest//:gtest",
+    ],
+)
+
 cc_library(
     name = "lazy_query_engine",
     hdrs = [
@@ -4310,6 +4337,7 @@ cc_test(
         ":optimization_pass",
         ":pass_base",
         ":query_engine",
+        ":reachability_analysis",
         ":resource_sharing_pass",
         "//xls/common:xls_gunit_main",
         "//xls/common/fuzzing:fuzztest",

xls/passes/reachability_analysis.cc

@@ -0,0 +1,50 @@
+// Copyright 2025 The XLS Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "xls/passes/reachability_analysis.h"
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/types/span.h"
+#include "xls/ir/node.h"
+
+namespace xls {
+
+bool ReachabilityAnalysis::IsReachableFrom(Node* end, Node* start) const {
+  return GetInfo(end)->contains(start);
+}
+
+absl::flat_hash_set<Node*> ReachabilityAnalysis::ComputeInfo(
+    Node* end,
+    absl::Span<const absl::flat_hash_set<Node*>* const> operand_infos) const {
+  int max_size = 0;
+  for (const absl::flat_hash_set<Node*>* operand_info : operand_infos) {
+    max_size += operand_info->size();
+  }
+  absl::flat_hash_set<Node*> can_reach_end{end};
+  can_reach_end.reserve(max_size + 1);
+  for (const absl::flat_hash_set<Node*>* operand_info : operand_infos) {
+    can_reach_end.insert(operand_info->begin(), operand_info->end());
+  }
+  return can_reach_end;
+}
+
+absl::Status ReachabilityAnalysis::MergeWithGiven(
+    absl::flat_hash_set<Node*>& info,
+    const absl::flat_hash_set<Node*>& given) const {
+  info.insert(given.begin(), given.end());
+  return absl::OkStatus();
+}
+
+}  // namespace xls

xls/passes/reachability_analysis.h

@@ -0,0 +1,49 @@
+// Copyright 2025 The XLS Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef XLS_PASSES_REACHABILITY_ANALYSIS_H_
+#define XLS_PASSES_REACHABILITY_ANALYSIS_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/types/span.h"
+#include "xls/ir/node.h"
+#include "xls/passes/lazy_node_data.h"
+
+namespace xls {
+
+class ReachabilityAnalysis : public LazyNodeData<absl::flat_hash_set<Node*>> {
+ public:
+  // Returns if `end` can be reached by traversing users beginning at `start`.
+  bool IsReachableFrom(Node* end, Node* start) const;
+
+  const absl::flat_hash_set<Node*>& NodesThatCanReach(Node* end) const {
+    return *GetInfo(end);
+  }
+
+ protected:
+  // Computes the set of nodes reach-able from `start` by traversing users.
+  absl::flat_hash_set<Node*> ComputeInfo(
+      Node* end,
+      absl::Span<const absl::flat_hash_set<Node*>* const> operand_infos)
+      const override;
+
+  absl::Status MergeWithGiven(
+      absl::flat_hash_set<Node*>& info,
+      const absl::flat_hash_set<Node*>& given) const override;
+};
+
+}  // namespace xls
+
+#endif  // XLS_PASSES_REACHABILITY_ANALYSIS_H_

xls/passes/reachability_analysis_test.cc

@@ -0,0 +1,78 @@
+// Copyright 2025 The XLS Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "xls/passes/reachability_analysis.h"
+
+#include "gtest/gtest.h"
+#include "xls/common/status/matchers.h"
+#include "xls/ir/function_builder.h"
+#include "xls/ir/ir_test_base.h"
+#include "xls/ir/node.h"
+#include "xls/ir/op.h"
+#include "xls/ir/package.h"
+
+namespace xls {
+namespace {
+
+class ReachabilityAnalysisTest : public IrTestBase {
+ protected:
+  bool IsReachableFrom(const ReachabilityAnalysis& reachability, Node* end,
+                       Node* start) {
+    return reachability.IsReachableFrom(end, start);
+  }
+};
+
+TEST_F(ReachabilityAnalysisTest, SuccessorsAreReachableButPredecessorsAreNot) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(4));
+  BValue y = fb.Add(x, x);
+  BValue z = fb.UMul(x, y);
+  BValue w = fb.Subtract(z, x);
+  XLS_ASSERT_OK(fb.BuildWithReturnValue(w));
+  ReachabilityAnalysis reachability;
+
+  EXPECT_TRUE(IsReachableFrom(reachability, x.node(), x.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, y.node(), x.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, z.node(), x.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, w.node(), x.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, z.node(), y.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, w.node(), y.node()));
+  EXPECT_TRUE(IsReachableFrom(reachability, z.node(), y.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, x.node(), y.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, x.node(), z.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, x.node(), w.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, y.node(), z.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, y.node(), w.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, z.node(), w.node()));
+}
+
+TEST_F(ReachabilityAnalysisTest, SiblingsCannotReachEachOther) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue a = fb.Param("a", p->GetBitsType(4));
+  BValue b = fb.Param("b", p->GetBitsType(4));
+  BValue x = fb.Or(a, b);
+  BValue y1 = fb.Add(x, a);
+  BValue y2 = fb.Subtract(x, b);
+  BValue z = fb.UMul(y1, y2);
+  XLS_ASSERT_OK(fb.BuildWithReturnValue(z));
+  ReachabilityAnalysis reachability;
+
+  EXPECT_FALSE(IsReachableFrom(reachability, y1.node(), y2.node()));
+  EXPECT_FALSE(IsReachableFrom(reachability, y2.node(), y1.node()));
+}
+
+}  // namespace
+}  // namespace xls