rbt

Author: yury-intel

src/plugins/intel_gpu/include/intel_gpu/runtime/memory_pool.hpp

@@ -26,44 +26,49 @@ class engine;
 using primitive_id = std::string;
 using memory_ptr = std::shared_ptr<memory>;
 
-template<typename Key, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
+template<typename Key>
 class memory_restricter {
     private:
-        const std::unordered_set<Key, Hash, KeyEqual>* set1;  // Const reference to immutable set
-        std::unordered_set<Key, Hash, KeyEqual> set2;         // Internal mutable set
+        const std::set<Key>* set1;  // Const reference to immutable set
+        std::set<Key> set2;         // Internal mutable set
 
     public:
         memory_restricter() : set1(nullptr) {};
 
         // Constructor to initialize with a const reference for set1
-        explicit memory_restricter(const std::unordered_set<Key, Hash, KeyEqual>* externalSet)
+        explicit memory_restricter(const std::set<Key>* externalSet)
             : set1(externalSet) {}
 
         // Insert into set2 (set1 is read-only)
         void insert(const Key& key) {
-            if (set1->find(key) == set1->end())
+            if (!set1 || set1->find(key) == set1->end())
                 set2.insert(key);
         }
 
         // Check existence in either set
         bool contains(const Key& key) const {
-            return set1->find(key) != set1->end() || set2.find(key) != set2.end();
+            const bool in_set1 = set1 ? (set1->find(key) != set1->end()) : false;
+            return in_set1 || set2.find(key) != set2.end();
         }
 
         // Total size of both sets
         size_t size() const {
-            return set1->size() + set2.size();
+            return (set1 ? set1->size() : 0) + set2.size();
         }
 
         // Check if both sets are empty
         bool empty() const {
-            return set1->empty() && set2.empty();
+            return (!set1 || set1->empty()) && set2.empty();
         }
 
         // Iterate over both sets
         void for_each(void(*func)(const Key&)) const {
-            for (const auto& key : set1) func(key);
-            for (const auto& key : set2) func(key);
+            if (set1) {
+                for (const auto& key : *set1)
+                    func(key);
+            }
+            for (const auto& key : set2)
+                func(key);
         }
 }; // end of memory_restricter
 

src/plugins/intel_gpu/src/graph/include/program_node.h

@@ -210,7 +210,7 @@ struct program_node {
     size_t get_dependency_index(const program_node& node) const;
     size_t get_user_index(const program_node& node) const;
 
-    const std::unordered_set<uint32_t>& get_memory_dependencies() const;
+    const std::set<uint32_t>& get_memory_dependencies() const;
 
     void add_memory_dependency(std::vector<size_t>);
     void add_memory_dependency(const program_node& node);
@@ -506,7 +506,7 @@ struct program_node {
     std::list<program_node*> users;
 
     // list of primitives that can reuse same memory buffers due to execution order conflicts
-    std::unordered_set<uint32_t> memory_dependencies;
+    std::set<uint32_t> memory_dependencies;
 
     impl_types impl_type = impl_types::any;
     impl_types forced_impl_type = impl_types::any;

src/plugins/intel_gpu/src/graph/program_node.cpp

@@ -195,7 +195,7 @@ void program_node::remove_dependency(size_t idx) {
     dependencies.erase(dependencies.begin() + idx);
 }
 
-const std::unordered_set<uint32_t>& program_node::get_memory_dependencies() const { return memory_dependencies; }
+const std::set<uint32_t>& program_node::get_memory_dependencies() const { return memory_dependencies; }
 
 void program_node::add_memory_dependency(std::vector<size_t> prim_list) {
     for (size_t val : prim_list) {