diff --git a/sycl/source/detail/graph/graph_impl.cpp b/sycl/source/detail/graph/graph_impl.cpp
index 0f7a7195aeff..76528ce16653 100644
--- a/sycl/source/detail/graph/graph_impl.cpp
+++ b/sycl/source/detail/graph/graph_impl.cpp
@@ -1321,11 +1321,9 @@ void exec_graph_impl::duplicateNodes() {
       auto &Successors = PredNode.MSuccessors;
 
       // Remove the subgraph node from this nodes successors
-      Successors.erase(std::remove_if(Successors.begin(), Successors.end(),
-                                      [NewNode](auto WeakNode) {
-                                        return WeakNode.lock() == NewNode;
-                                      }),
-                       Successors.end());
+      Successors.erase(
+          std::remove(Successors.begin(), Successors.end(), NewNode.get()),
+          Successors.end());
 
       // Add all input nodes from the subgraph as successors for this node
       // instead
@@ -1339,12 +1337,9 @@ void exec_graph_impl::duplicateNodes() {
       auto &Predecessors = SuccNode.MPredecessors;
 
       // Remove the subgraph node from this nodes successors
-      Predecessors.erase(std::remove_if(Predecessors.begin(),
-                                        Predecessors.end(),
-                                        [NewNode](auto WeakNode) {
-                                          return WeakNode.lock() == NewNode;
-                                        }),
-                         Predecessors.end());
+      Predecessors.erase(
+          std::remove(Predecessors.begin(), Predecessors.end(), NewNode.get()),
+          Predecessors.end());
 
       // Add all Output nodes from the subgraph as predecessors for this node
       // instead
diff --git a/sycl/source/detail/graph/node_impl.hpp b/sycl/source/detail/graph/node_impl.hpp
index aed90d3f0490..c440b5962430 100644
--- a/sycl/source/detail/graph/node_impl.hpp
+++ b/sycl/source/detail/graph/node_impl.hpp
@@ -93,11 +93,11 @@ class node_impl : public std::enable_shared_from_this<node_impl> {
   /// Unique identifier for this node.
   id_type MID = getNextNodeID();
   /// List of successors to this node.
-  std::vector<std::weak_ptr<node_impl>> MSuccessors;
+  std::vector<node_impl *> MSuccessors;
   /// List of predecessors to this node.
   ///
   /// Using weak_ptr here to prevent circular references between nodes.
-  std::vector<std::weak_ptr<node_impl>> MPredecessors;
+  std::vector<node_impl *> MPredecessors;
   /// Type of the command-group for the node.
   sycl::detail::CGType MCGType = sycl::detail::CGType::None;
   /// User facing type of the node.
@@ -123,26 +123,22 @@ class node_impl : public std::enable_shared_from_this<node_impl> {
   /// Add successor to the node.
   /// @param Node Node to add as a successor.
   void registerSuccessor(node_impl &Node) {
-    if (std::find_if(MSuccessors.begin(), MSuccessors.end(),
-                     [&Node](const std::weak_ptr<node_impl> &Ptr) {
-                       return Ptr.lock().get() == &Node;
-                     }) != MSuccessors.end()) {
+    if (std::find(MSuccessors.begin(), MSuccessors.end(), &Node) !=
+        MSuccessors.end()) {
       return;
     }
-    MSuccessors.push_back(Node.weak_from_this());
+    MSuccessors.push_back(&Node);
     Node.registerPredecessor(*this);
   }
 
   /// Add predecessor to the node.
   /// @param Node Node to add as a predecessor.
   void registerPredecessor(node_impl &Node) {
-    if (std::find_if(MPredecessors.begin(), MPredecessors.end(),
-                     [&Node](const std::weak_ptr<node_impl> &Ptr) {
-                       return Ptr.lock().get() == &Node;
-                     }) != MPredecessors.end()) {
+    if (std::find(MPredecessors.begin(), MPredecessors.end(), &Node) !=
+        MPredecessors.end()) {
       return;
     }
-    MPredecessors.push_back(Node.weak_from_this());
+    MPredecessors.push_back(&Node);
   }
 
   /// Construct an empty node.
@@ -393,15 +389,13 @@ class node_impl : public std::enable_shared_from_this<node_impl> {
     Visited.push_back(this);
 
     printDotCG(Stream, Verbose);
-    for (const auto &Dep : MPredecessors) {
-      auto NodeDep = Dep.lock();
-      Stream << "  \"" << NodeDep.get() << "\" -> \"" << this << "\""
-             << std::endl;
+    for (node_impl *Pred : MPredecessors) {
+      Stream << "  \"" << Pred << "\" -> \"" << this << "\"" << std::endl;
     }
 
-    for (std::weak_ptr<node_impl> Succ : MSuccessors) {
-      if (MPartitionNum == Succ.lock()->MPartitionNum)
-        Succ.lock()->printDotRecursive(Stream, Visited, Verbose);
+    for (node_impl *Succ : MSuccessors) {
+      if (MPartitionNum == Succ->MPartitionNum)
+        Succ->printDotRecursive(Stream, Visited, Verbose);
     }
   }
 
diff --git a/sycl/unittests/Extensions/CommandGraph/Barrier.cpp b/sycl/unittests/Extensions/CommandGraph/Barrier.cpp
index 9b516c22ee78..c43d3eb74ffa 100644
--- a/sycl/unittests/Extensions/CommandGraph/Barrier.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/Barrier.cpp
@@ -41,12 +41,12 @@ TEST_F(CommandGraphTest, EnqueueBarrier) {
   ASSERT_EQ(GraphImpl.MRoots.size(), 3lu);
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-    auto BarrierNode = Root.MSuccessors.front().lock();
-    ASSERT_EQ(BarrierNode->MCGType, sycl::detail::CGType::Barrier);
-    ASSERT_EQ(GraphImpl.getEventForNode(*BarrierNode).get(),
+    experimental::detail::node_impl &BarrierNode = *Root.MSuccessors.front();
+    ASSERT_EQ(BarrierNode.MCGType, sycl::detail::CGType::Barrier);
+    ASSERT_EQ(GraphImpl.getEventForNode(BarrierNode).get(),
               &*getSyclObjImpl(Barrier));
-    ASSERT_EQ(BarrierNode->MPredecessors.size(), 3lu);
-    ASSERT_EQ(BarrierNode->MSuccessors.size(), 2lu);
+    ASSERT_EQ(BarrierNode.MPredecessors.size(), 3lu);
+    ASSERT_EQ(BarrierNode.MSuccessors.size(), 2lu);
   }
 }
 
@@ -82,25 +82,24 @@ TEST_F(CommandGraphTest, EnqueueBarrierMultipleQueues) {
     if (GraphImpl.getEventForNode(Root).get() == &*getSyclObjImpl(Node2Graph)) {
 
       ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-      auto SuccNode = Root.MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 2lu);
 
-      for (auto SuccSucc : SuccNode->MSuccessors) {
-        auto SuccSuccNode = SuccSucc.lock();
-
-        if (GraphImpl.getEventForNode(*SuccSuccNode).get() ==
+      for (experimental::detail::node_impl &SuccSuccNode :
+           SuccNode.successors()) {
+        if (GraphImpl.getEventForNode(SuccSuccNode).get() ==
             &*getSyclObjImpl(Node4Graph)) {
-          ASSERT_EQ(SuccSuccNode->MPredecessors.size(), 1lu);
-          ASSERT_EQ(SuccSuccNode->MSuccessors.size(), 0lu);
-        } else if (GraphImpl.getEventForNode(*SuccSuccNode).get() ==
+          ASSERT_EQ(SuccSuccNode.MPredecessors.size(), 1lu);
+          ASSERT_EQ(SuccSuccNode.MSuccessors.size(), 0lu);
+        } else if (GraphImpl.getEventForNode(SuccSuccNode).get() ==
                    &*getSyclObjImpl(Node5Graph)) {
-          ASSERT_EQ(SuccSuccNode->MPredecessors.size(), 1lu);
-          ASSERT_EQ(SuccSuccNode->MSuccessors.size(), 0lu);
+          ASSERT_EQ(SuccSuccNode.MPredecessors.size(), 1lu);
+          ASSERT_EQ(SuccSuccNode.MSuccessors.size(), 0lu);
         } else {
           ASSERT_TRUE(false && "Unexpected node");
         }
@@ -145,15 +144,15 @@ TEST_F(CommandGraphTest, EnqueueBarrierWaitList) {
   ASSERT_EQ(GraphImpl.MRoots.size(), 3lu);
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-    auto SuccNode = Root.MSuccessors.front().lock();
-    if (SuccNode->MCGType == sycl::detail::CGType::Barrier) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+    experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+    if (SuccNode.MCGType == sycl::detail::CGType::Barrier) {
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier));
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 2lu);
     } else {
       // Node 5
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
     }
   }
 }
@@ -201,15 +200,15 @@ TEST_F(CommandGraphTest, EnqueueBarrierWaitListMultipleQueues) {
   ASSERT_EQ(GraphImpl.MRoots.size(), 3lu);
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-    auto SuccNode = Root.MSuccessors.front().lock();
-    if (SuccNode->MCGType == sycl::detail::CGType::Barrier) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+    experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+    if (SuccNode.MCGType == sycl::detail::CGType::Barrier) {
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier));
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 3lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 3lu);
     } else {
       // Node 5
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
     }
   }
 }
@@ -263,21 +262,21 @@ TEST_F(CommandGraphTest, EnqueueMultipleBarrier) {
   ASSERT_EQ(GraphImpl.MRoots.size(), 3lu);
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-    auto SuccNode = Root.MSuccessors.front().lock();
-    if (SuccNode->MCGType == sycl::detail::CGType::Barrier) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+    experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+    if (SuccNode.MCGType == sycl::detail::CGType::Barrier) {
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier1));
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 3lu);
-      for (auto Succ1 : SuccNode->MSuccessors) {
-        auto SuccBarrier1 = Succ1.lock();
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 3lu);
+      for (auto Succ1 : SuccNode.MSuccessors) {
+        auto SuccBarrier1 = Succ1;
         if (SuccBarrier1->MCGType == sycl::detail::CGType::Barrier) {
           ASSERT_EQ(GraphImpl.getEventForNode(*SuccBarrier1).get(),
                     &*getSyclObjImpl(Barrier2));
           ASSERT_EQ(SuccBarrier1->MPredecessors.size(), 3lu);
           ASSERT_EQ(SuccBarrier1->MSuccessors.size(), 3lu);
           for (auto Succ2 : SuccBarrier1->MSuccessors) {
-            auto SuccBarrier2 = Succ2.lock();
+            auto SuccBarrier2 = Succ2;
             // Nodes 6, 7, 8
             ASSERT_EQ(SuccBarrier2->MPredecessors.size(), 1lu);
             ASSERT_EQ(SuccBarrier2->MSuccessors.size(), 0lu);
@@ -294,8 +293,8 @@ TEST_F(CommandGraphTest, EnqueueMultipleBarrier) {
       }
     } else {
       // Node 5
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 1lu);
     }
   }
 }
@@ -366,11 +365,11 @@ TEST_F(CommandGraphTest, InOrderQueuesWithBarrier) {
     if (GraphImpl.getEventForNode(Root).get() == &*getSyclObjImpl(Node1)) {
       ASSERT_EQ(Root.MSuccessors.size(), 1lu);
 
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_TRUE(SuccNode->MCGType == sycl::detail::CGType::Barrier);
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_TRUE(SuccNode.MCGType == sycl::detail::CGType::Barrier);
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else if (GraphImpl.getEventForNode(Root).get() ==
                &*getSyclObjImpl(Node2)) {
       ASSERT_EQ(Root.MSuccessors.size(), 0lu);
@@ -410,12 +409,12 @@ TEST_F(CommandGraphTest, InOrderQueuesWithBarrierWaitList) {
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     ASSERT_EQ(Root.MSuccessors.size(), 1lu);
 
-    auto SuccNode = Root.MSuccessors.front().lock();
-    ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+    experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+    ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
               &*getSyclObjImpl(BarrierNode));
 
-    ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-    ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+    ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+    ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
   }
 }
 
@@ -453,24 +452,24 @@ TEST_F(CommandGraphTest, InOrderQueuesWithEmptyBarrierWaitList) {
     if (GraphImpl.getEventForNode(Root).get() == &*getSyclObjImpl(Node1)) {
       ASSERT_EQ(Root.MSuccessors.size(), 1lu);
 
-      auto SuccNode = Root.MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(BarrierNode));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else if (GraphImpl.getEventForNode(Root).get() ==
                &*getSyclObjImpl(Node2)) {
       ASSERT_EQ(Root.MSuccessors.size(), 1lu);
 
-      auto SuccNode = Root.MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Node3));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else {
       ASSERT_TRUE(false && "Unexpected root node");
     }
@@ -521,17 +520,15 @@ TEST_F(CommandGraphTest, BarrierMixedQueueTypes) {
       ASSERT_TRUE(false && "Unexpected root node");
     }
 
-    for (auto Succ : Root.MSuccessors) {
-      auto SuccNode = Succ.lock();
-
-      if (GraphImpl.getEventForNode(*SuccNode).get() ==
+    for (experimental::detail::node_impl &SuccNode : Root.successors()) {
+      if (GraphImpl.getEventForNode(SuccNode).get() ==
           &*getSyclObjImpl(BarrierNode)) {
-        ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-        ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
-      } else if (GraphImpl.getEventForNode(*SuccNode).get() ==
+        ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+        ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
+      } else if (GraphImpl.getEventForNode(SuccNode).get() ==
                  &*getSyclObjImpl(Node3)) {
-        ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-        ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+        ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+        ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
       } else {
         ASSERT_TRUE(false && "Unexpected root node");
       }
@@ -571,8 +568,8 @@ TEST_F(CommandGraphTest, BarrierBetweenExplicitNodes) {
       ASSERT_EQ(Root.MSuccessors.size(), 0lu);
     } else if (&Root == &*getSyclObjImpl(Node1)) {
       ASSERT_EQ(Root.MSuccessors.size(), 1lu);
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(SuccNode.get(), &*getSyclObjImpl(Node2));
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(&SuccNode, &*getSyclObjImpl(Node2));
     } else {
       ASSERT_TRUE(false);
     }
@@ -624,30 +621,31 @@ TEST_F(CommandGraphTest, BarrierMultipleOOOQueue) {
     if ((RootNodeEvent.get() == &*getSyclObjImpl(Node1)) ||
         (RootNodeEvent.get() == &*getSyclObjImpl(Node2))) {
 
-      auto SuccNode = Root.MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(BarrierNode));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 1lu);
 
-      auto SuccSuccNode = SuccNode->MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccSuccNode =
+          *SuccNode.MSuccessors.front();
 
-      ASSERT_EQ(SuccSuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccSuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccSuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccSuccNode.MSuccessors.size(), 0lu);
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccSuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccSuccNode).get(),
                 &*getSyclObjImpl(Node6));
     } else if ((RootNodeEvent.get() == &*getSyclObjImpl(Node3)) ||
                (RootNodeEvent.get() == &*getSyclObjImpl(Node4))) {
-      auto SuccNode = Root.MSuccessors.front().lock();
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
 
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Node5));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 2lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 2lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else {
       ASSERT_TRUE(false);
     }
@@ -686,19 +684,19 @@ TEST_F(CommandGraphTest, BarrierMultipleInOrderQueue) {
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     auto RootNodeEvent = GraphImpl.getEventForNode(Root);
     if (RootNodeEvent.get() == &*getSyclObjImpl(Node1)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(BarrierNode));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else if (RootNodeEvent.get() == &*getSyclObjImpl(Node2)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Node3));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else {
       ASSERT_TRUE(false);
     }
@@ -736,19 +734,19 @@ TEST_F(CommandGraphTest, BarrierMultipleMixedOrderQueues) {
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     auto RootNodeEvent = GraphImpl.getEventForNode(Root);
     if (RootNodeEvent.get() == &*getSyclObjImpl(Node1)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(BarrierNode));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else if (RootNodeEvent.get() == &*getSyclObjImpl(Node2)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Node3));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else {
       ASSERT_TRUE(false);
     }
@@ -780,19 +778,19 @@ TEST_F(CommandGraphTest, BarrierMultipleQueuesMultipleBarriers) {
   for (experimental::detail::node_impl &Root : GraphImpl.roots()) {
     auto RootNodeEvent = GraphImpl.getEventForNode(Root);
     if (RootNodeEvent.get() == &*getSyclObjImpl(Barrier1)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier4));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else if (RootNodeEvent.get() == &*getSyclObjImpl(Barrier2)) {
-      auto SuccNode = Root.MSuccessors.front().lock();
-      ASSERT_EQ(GraphImpl.getEventForNode(*SuccNode).get(),
+      experimental::detail::node_impl &SuccNode = *Root.MSuccessors.front();
+      ASSERT_EQ(GraphImpl.getEventForNode(SuccNode).get(),
                 &*getSyclObjImpl(Barrier3));
 
-      ASSERT_EQ(SuccNode->MPredecessors.size(), 1lu);
-      ASSERT_EQ(SuccNode->MSuccessors.size(), 0lu);
+      ASSERT_EQ(SuccNode.MPredecessors.size(), 1lu);
+      ASSERT_EQ(SuccNode.MSuccessors.size(), 0lu);
     } else {
       ASSERT_TRUE(false);
     }
@@ -867,50 +865,50 @@ TEST_F(CommandGraphTest, BarrierWithInOrderCommands) {
       ASSERT_TRUE(false);
     }
 
-    auto Succ1Node = Root.MSuccessors.front().lock();
-    ASSERT_EQ(Succ1Node->MSuccessors.size(), 1lu);
+    experimental::detail::node_impl &Succ1Node = *Root.MSuccessors.front();
+    ASSERT_EQ(Succ1Node.MSuccessors.size(), 1lu);
     if (EvenPath) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ1Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ1Node).get(),
                 &*getSyclObjImpl(Barrier2));
     } else {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ1Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ1Node).get(),
                 &*getSyclObjImpl(Barrier1));
     }
 
-    auto Succ2Node = Succ1Node->MSuccessors.front().lock();
-    ASSERT_EQ(Succ2Node->MSuccessors.size(), 1lu);
+    experimental::detail::node_impl &Succ2Node = *Succ1Node.MSuccessors.front();
+    ASSERT_EQ(Succ2Node.MSuccessors.size(), 1lu);
     if (EvenPath) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ2Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ2Node).get(),
                 &*getSyclObjImpl(Node4));
     } else {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ2Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ2Node).get(),
                 &*getSyclObjImpl(Node3));
     }
 
-    auto Succ3Node = Succ2Node->MSuccessors.front().lock();
-    ASSERT_EQ(Succ3Node->MSuccessors.size(), 1lu);
+    experimental::detail::node_impl &Succ3Node = *Succ2Node.MSuccessors.front();
+    ASSERT_EQ(Succ3Node.MSuccessors.size(), 1lu);
     if (EvenPath) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ3Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ3Node).get(),
                 &*getSyclObjImpl(Barrier4));
     } else {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ3Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ3Node).get(),
                 &*getSyclObjImpl(Barrier3));
     }
 
-    auto Succ4Node = Succ3Node->MSuccessors.front().lock();
-    ASSERT_EQ(Succ4Node->MSuccessors.size(), 1lu);
+    experimental::detail::node_impl &Succ4Node = *Succ3Node.MSuccessors.front();
+    ASSERT_EQ(Succ4Node.MSuccessors.size(), 1lu);
     if (EvenPath) {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ4Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ4Node).get(),
                 &*getSyclObjImpl(Node6));
     } else {
-      ASSERT_EQ(GraphImpl.getEventForNode(*Succ4Node).get(),
+      ASSERT_EQ(GraphImpl.getEventForNode(Succ4Node).get(),
                 &*getSyclObjImpl(Node5));
     }
 
-    auto Succ5Node = Succ4Node->MSuccessors.front().lock();
-    ASSERT_EQ(Succ5Node->MSuccessors.size(), 0lu);
-    ASSERT_EQ(Succ5Node->MPredecessors.size(), 2lu);
-    ASSERT_EQ(GraphImpl.getEventForNode(*Succ5Node).get(),
+    experimental::detail::node_impl &Succ5Node = *Succ4Node.MSuccessors.front();
+    ASSERT_EQ(Succ5Node.MSuccessors.size(), 0lu);
+    ASSERT_EQ(Succ5Node.MPredecessors.size(), 2lu);
+    ASSERT_EQ(GraphImpl.getEventForNode(Succ5Node).get(),
               &*getSyclObjImpl(Barrier5));
   }
 }
diff --git a/sycl/unittests/Extensions/CommandGraph/CommandGraph.cpp b/sycl/unittests/Extensions/CommandGraph/CommandGraph.cpp
index 9799847d88d9..82fc0ed56c09 100644
--- a/sycl/unittests/Extensions/CommandGraph/CommandGraph.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/CommandGraph.cpp
@@ -71,7 +71,7 @@ TEST_F(CommandGraphTest, AddNode) {
   ASSERT_TRUE(getSyclObjImpl(Node2)->isEmpty());
   ASSERT_EQ(GraphImpl.MRoots.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.size(), 1lu);
-  ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.front().lock().get(),
+  ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.front(),
             &*getSyclObjImpl(Node2));
   ASSERT_TRUE(getSyclObjImpl(Node1)->MPredecessors.empty());
   ASSERT_EQ(getSyclObjImpl(Node2)->MPredecessors.size(), 1lu);
@@ -154,7 +154,7 @@ TEST_F(CommandGraphTest, MakeEdge) {
   Graph.make_edge(Node1, Node2);
   ASSERT_EQ(GraphImpl.MRoots.size(), 1ul);
   ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.size(), 1lu);
-  ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.front().lock().get(),
+  ASSERT_EQ(getSyclObjImpl(Node1)->MSuccessors.front(),
             &*getSyclObjImpl(Node2));
   ASSERT_TRUE(getSyclObjImpl(Node1)->MPredecessors.empty());
   ASSERT_TRUE(getSyclObjImpl(Node2)->MSuccessors.empty());
@@ -241,13 +241,13 @@ TEST_F(CommandGraphTest, DependencyLeavesKeyword1) {
 
   experimental::detail::node_impl &Node1Impl = *getSyclObjImpl(Node1Graph);
   ASSERT_EQ(Node1Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node1Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node1Impl.MSuccessors[0], &EmptyImpl);
   experimental::detail::node_impl &Node2Impl = *getSyclObjImpl(Node2Graph);
   ASSERT_EQ(Node2Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node2Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node2Impl.MSuccessors[0], &EmptyImpl);
   experimental::detail::node_impl &Node3Impl = *getSyclObjImpl(Node3Graph);
   ASSERT_EQ(Node3Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node3Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node3Impl.MSuccessors[0], &EmptyImpl);
 }
 
 TEST_F(CommandGraphTest, DependencyLeavesKeyword2) {
@@ -280,17 +280,17 @@ TEST_F(CommandGraphTest, DependencyLeavesKeyword2) {
 
   experimental::detail::node_impl &Node1Impl = *getSyclObjImpl(Node1Graph);
   ASSERT_EQ(Node1Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node1Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node1Impl.MSuccessors[0], &EmptyImpl);
   experimental::detail::node_impl &Node2Impl = *getSyclObjImpl(Node2Graph);
   ASSERT_EQ(Node2Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node2Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node2Impl.MSuccessors[0], &EmptyImpl);
   experimental::detail::node_impl &Node3Impl = *getSyclObjImpl(Node3Graph);
   ASSERT_EQ(Node3Impl.MSuccessors.size(), 1lu);
 
   experimental::detail::node_impl &Node4Impl = *getSyclObjImpl(Node4Graph);
   ASSERT_EQ(Node4Impl.MPredecessors.size(), 1lu);
   ASSERT_EQ(Node4Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node4Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node4Impl.MSuccessors[0], &EmptyImpl);
 }
 
 TEST_F(CommandGraphTest, DependencyLeavesKeyword3) {
@@ -325,15 +325,15 @@ TEST_F(CommandGraphTest, DependencyLeavesKeyword3) {
   experimental::detail::node_impl &Node2Impl = *getSyclObjImpl(Node2Graph);
   ASSERT_EQ(Node1Impl.MSuccessors.size(), 2lu);
   ASSERT_EQ(Node2Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node2Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node2Impl.MSuccessors[0], &EmptyImpl);
 
   experimental::detail::node_impl &Node3Impl = *getSyclObjImpl(Node3Graph);
   ASSERT_EQ(Node3Impl.MPredecessors.size(), 1lu);
-  ASSERT_EQ(Node3Impl.MPredecessors[0].lock().get(), &Node1Impl);
+  ASSERT_EQ(Node3Impl.MPredecessors[0], &Node1Impl);
 
   experimental::detail::node_impl &Node4Impl = *getSyclObjImpl(Node4Graph);
   ASSERT_EQ(Node4Impl.MPredecessors.size(), 1lu);
-  ASSERT_EQ(Node4Impl.MPredecessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node4Impl.MPredecessors[0], &EmptyImpl);
 }
 
 TEST_F(CommandGraphTest, DependencyLeavesKeyword4) {
@@ -365,16 +365,16 @@ TEST_F(CommandGraphTest, DependencyLeavesKeyword4) {
 
   experimental::detail::node_impl &Node1Impl = *getSyclObjImpl(Node1Graph);
   ASSERT_EQ(Node1Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node1Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node1Impl.MSuccessors[0], &EmptyImpl);
   experimental::detail::node_impl &Node2Impl = *getSyclObjImpl(Node2Graph);
   ASSERT_EQ(Node2Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node2Impl.MSuccessors[0].lock().get(), &EmptyImpl);
+  ASSERT_EQ(Node2Impl.MSuccessors[0], &EmptyImpl);
 
   experimental::detail::node_impl &EmptyImpl2 = *getSyclObjImpl(EmptyNode2);
   experimental::detail::node_impl &Node3Impl = *getSyclObjImpl(Node3Graph);
   ASSERT_EQ(Node3Impl.MPredecessors.size(), 0lu);
   ASSERT_EQ(Node3Impl.MSuccessors.size(), 1lu);
-  ASSERT_EQ(Node3Impl.MSuccessors[0].lock().get(), &EmptyImpl2);
+  ASSERT_EQ(Node3Impl.MSuccessors[0], &EmptyImpl2);
 
   ASSERT_EQ(EmptyImpl2.MPredecessors.size(), 2lu);
 }
diff --git a/sycl/unittests/Extensions/CommandGraph/Exceptions.cpp b/sycl/unittests/Extensions/CommandGraph/Exceptions.cpp
index ab651e140fe8..42444dff8289 100644
--- a/sycl/unittests/Extensions/CommandGraph/Exceptions.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/Exceptions.cpp
@@ -511,11 +511,11 @@ TEST_F(CommandGraphTest, MakeEdgeErrors) {
 
     ASSERT_EQ(NodeAImpl.MSuccessors.size(), 1lu);
     ASSERT_EQ(NodeAImpl.MPredecessors.size(), 0lu);
-    ASSERT_EQ(NodeAImpl.MSuccessors.front().lock().get(), &NodeBImpl);
+    ASSERT_EQ(NodeAImpl.MSuccessors.front(), &NodeBImpl);
 
     ASSERT_EQ(NodeBImpl.MSuccessors.size(), 0lu);
     ASSERT_EQ(NodeBImpl.MPredecessors.size(), 1lu);
-    ASSERT_EQ(NodeBImpl.MPredecessors.front().lock().get(), &NodeAImpl);
+    ASSERT_EQ(NodeBImpl.MPredecessors.front(), &NodeAImpl);
   };
   // Make a normal edge
   ASSERT_NO_THROW(Graph.make_edge(NodeA, NodeB));
diff --git a/sycl/unittests/Extensions/CommandGraph/InOrderQueue.cpp b/sycl/unittests/Extensions/CommandGraph/InOrderQueue.cpp
index 17703be2de59..5e32c7b7a4b6 100644
--- a/sycl/unittests/Extensions/CommandGraph/InOrderQueue.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/InOrderQueue.cpp
@@ -35,9 +35,9 @@ TEST_F(CommandGraphTest, InOrderQueue) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -47,9 +47,9 @@ TEST_F(CommandGraphTest, InOrderQueue) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -92,9 +92,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmpty) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -104,9 +104,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmpty) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -150,9 +150,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmptyFirst) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -162,9 +162,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmptyFirst) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -209,9 +209,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmptyLast) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit([&](sycl::handler &cgh) {});
 
@@ -220,9 +220,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithEmptyLast) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -279,9 +279,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithPreviousHostTask) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -291,9 +291,9 @@ TEST_F(CommandGraphTest, InOrderQueueWithPreviousHostTask) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -346,9 +346,9 @@ TEST_F(CommandGraphTest, InOrderQueueHostTaskAndGraph) {
     ASSERT_NE(PtrNode2, nullptr);
     ASSERT_NE(PtrNode2, PtrNode1);
     ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-    ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+    ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
     ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-    ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+    ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
     auto Node3Graph = InOrderQueue.submit(
         [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -358,9 +358,9 @@ TEST_F(CommandGraphTest, InOrderQueueHostTaskAndGraph) {
     ASSERT_NE(PtrNode3, nullptr);
     ASSERT_NE(PtrNode3, PtrNode2);
     ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-    ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+    ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
     ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-    ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+    ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
     InOrderGraph.end_recording(InOrderQueue);
 
@@ -423,9 +423,9 @@ TEST_F(CommandGraphTest, InOrderQueueMemsetAndGraph) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -435,9 +435,9 @@ TEST_F(CommandGraphTest, InOrderQueueMemsetAndGraph) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
@@ -483,9 +483,9 @@ TEST_F(CommandGraphTest, InOrderQueueMemcpyAndGraph) {
   ASSERT_NE(PtrNode2, nullptr);
   ASSERT_NE(PtrNode2, PtrNode1);
   ASSERT_EQ(PtrNode1->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode1->MSuccessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode1->MSuccessors.front(), PtrNode2);
   ASSERT_EQ(PtrNode2->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MPredecessors.front().lock().get(), PtrNode1);
+  ASSERT_EQ(PtrNode2->MPredecessors.front(), PtrNode1);
 
   auto Node3Graph = InOrderQueue.submit(
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([]() {}); });
@@ -495,9 +495,9 @@ TEST_F(CommandGraphTest, InOrderQueueMemcpyAndGraph) {
   ASSERT_NE(PtrNode3, nullptr);
   ASSERT_NE(PtrNode3, PtrNode2);
   ASSERT_EQ(PtrNode2->MSuccessors.size(), 1lu);
-  ASSERT_EQ(PtrNode2->MSuccessors.front().lock().get(), PtrNode3);
+  ASSERT_EQ(PtrNode2->MSuccessors.front(), PtrNode3);
   ASSERT_EQ(PtrNode3->MPredecessors.size(), 1lu);
-  ASSERT_EQ(PtrNode3->MPredecessors.front().lock().get(), PtrNode2);
+  ASSERT_EQ(PtrNode3->MPredecessors.front(), PtrNode2);
 
   InOrderGraph.end_recording(InOrderQueue);
 
diff --git a/sycl/unittests/Extensions/CommandGraph/MultiThreaded.cpp b/sycl/unittests/Extensions/CommandGraph/MultiThreaded.cpp
index fef1a947d0bc..1a9a9f30af9c 100644
--- a/sycl/unittests/Extensions/CommandGraph/MultiThreaded.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/MultiThreaded.cpp
@@ -252,7 +252,7 @@ TEST_F(MultiThreadGraphTest, RecordAddNodesInOrderQueue) {
     } else {
       // Check other nodes have 1 successor
       EXPECT_EQ(CurrentNode->MSuccessors.size(), 1lu);
-      CurrentNode = CurrentNode->MSuccessors[0].lock().get();
+      CurrentNode = CurrentNode->MSuccessors[0];
     }
   }
 }
diff --git a/sycl/unittests/Extensions/CommandGraph/Subgraph.cpp b/sycl/unittests/Extensions/CommandGraph/Subgraph.cpp
index e5f5defd5099..f1e6c0dec009 100644
--- a/sycl/unittests/Extensions/CommandGraph/Subgraph.cpp
+++ b/sycl/unittests/Extensions/CommandGraph/Subgraph.cpp
@@ -39,9 +39,8 @@ TEST_F(CommandGraphTest, SubGraph) {
   // Subgraph nodes are duplicated when inserted to parent graph on
   // finalization. we thus check the node content only.
   const bool CompareContentOnly = true;
-  ASSERT_TRUE(
-      getSyclObjImpl(Node1MainGraph)->MSuccessors.front().lock()->MNodeType ==
-      experimental::node_type::subgraph);
+  ASSERT_TRUE(getSyclObjImpl(Node1MainGraph)->MSuccessors.front()->MNodeType ==
+              experimental::node_type::subgraph);
   ASSERT_EQ(getSyclObjImpl(Node2MainGraph)->MSuccessors.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node1MainGraph)->MPredecessors.size(), 0lu);
   ASSERT_EQ(getSyclObjImpl(Node2MainGraph)->MPredecessors.size(), 1lu);
@@ -101,9 +100,8 @@ TEST_F(CommandGraphTest, SubGraphWithEmptyNode) {
   // Subgraph nodes are duplicated when inserted to parent graph.
   // we thus check the node content only.
   const bool CompareContentOnly = true;
-  ASSERT_TRUE(
-      getSyclObjImpl(Node1MainGraph)->MSuccessors.front().lock()->MNodeType ==
-      experimental::node_type::subgraph);
+  ASSERT_TRUE(getSyclObjImpl(Node1MainGraph)->MSuccessors.front()->MNodeType ==
+              experimental::node_type::subgraph);
   ASSERT_EQ(getSyclObjImpl(Node1MainGraph)->MSuccessors.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node2MainGraph)->MSuccessors.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node1MainGraph)->MPredecessors.size(), 0lu);
@@ -166,9 +164,8 @@ TEST_F(CommandGraphTest, SubGraphWithEmptyNodeLast) {
   // Subgraph nodes are duplicated when inserted to parent graph.
   // we thus check the node content only.
   const bool CompareContentOnly = true;
-  ASSERT_TRUE(
-      getSyclObjImpl(Node1MainGraph)->MSuccessors.front().lock()->MNodeType ==
-      experimental::node_type::subgraph);
+  ASSERT_TRUE(getSyclObjImpl(Node1MainGraph)->MSuccessors.front()->MNodeType ==
+              experimental::node_type::subgraph);
   ASSERT_EQ(getSyclObjImpl(Node1MainGraph)->MSuccessors.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node2MainGraph)->MSuccessors.size(), 1lu);
   ASSERT_EQ(getSyclObjImpl(Node1MainGraph)->MPredecessors.size(), 0lu);