Revised unique ID setting scheme. Previously it was using program id …

…to distinguish the loop body networks' id.

However, it results in cl cache miss for same network loaded multiple time, because program ids are differnt.
Now revised it to use parent primitive id instead of program_id for unique id of nodes in body networks.

src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp

@@ -128,7 +128,7 @@ struct program {
             build_options const& options,
             bool is_internal = false,
             bool no_optimizations = false,
-            bool is_body_program = false);
+            primitive_id parent_prim = "");
     /* constructor used to build a program from subset of nodes of other program (used in propagate_constants) */
     program(engine& engine_ref,
             std::set<std::shared_ptr<program_node>> const& nodes,
@@ -143,7 +143,8 @@ struct program {
     std::vector<program_node*>& get_outputs() {
         return outputs;
     }  // ToDo: redesign reorder-inputs pass to make it const as_well as get_engine and get options
-    bool is_loop_body() const { return is_body_program; }
+    bool is_loop_body() const { return parent_primitive != ""; }
+    primitive_id get_parent_primitive() const { return parent_primitive; }
     bool is_debug_build() const { return options.get<build_option_type::debug>()->enabled(); }
     const nodes_ordering& get_processing_order() const;
     nodes_ordering& get_processing_order();
@@ -224,7 +225,7 @@ struct program {
                              const build_options& options,
                              bool is_internal = false,
                              bool no_optimizations = false,
-                             bool is_body_program = false);
+                             primitive_id parent_primitive = "");
     static ptr build_program(engine& engine,
                              const std::set<std::shared_ptr<program_node>>& nodes,
                              const build_options& options,
@@ -253,7 +254,8 @@ struct program {
     nodes_ordering processing_order;
     std::unique_ptr<pass_manager> pm;
     std::shared_ptr<kernel_selector::TuningCache> tuning_cache;
-    bool is_body_program;
+
+    primitive_id parent_primitive;
 
     std::map<primitive_id, std::shared_ptr<program_node>> nodes_map;
     std::list<primitive_id> optimized_out;

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

@@ -343,7 +343,7 @@ struct typed_program_node<loop> : public typed_program_node_base<loop> {
         auto opts = get_program().get_options();
         std::vector<primitive_id> output_names_vec(output_names.begin(), output_names.end());
         opts.set_option(build_option::outputs(output_names_vec));
-        body_program = program::build_program(get_program().get_engine(), body, opts, false, false, true);
+        body_program = program::build_program(get_program().get_engine(), body, opts, false, false, this->id());
     }
 
     const primitive_id& get_trip_count_id() const { return get_primitive()->trip_count_id; }

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

@@ -7,6 +7,7 @@
 #include "intel_gpu/primitives/primitive.hpp"
 #include "intel_gpu/primitives/activation.hpp"
 #include "intel_gpu/primitives/implementation_desc.hpp"
+#include "intel_gpu/graph/program.hpp"
 
 #include "kernel_selector_helper.h"
 #include "meta_utils.h"
@@ -351,10 +352,18 @@ struct program_node {
     bool need_lockable_memory() const;
 
     std::string get_unique_id() const { return unique_id; }
-    void set_unique_id(std::string id) { unique_id = id; }
+    void set_unique_id(std::string id) {
+        unique_id = id;
+        if (myprog.get_parent_primitive() != "") {
+            auto loop_prim = myprog.get_parent_primitive();
+            std::replace(loop_prim.begin(), loop_prim.end(), '/', '_');
+            std::replace(loop_prim.begin(), loop_prim.end(), ':', '_');
+            unique_id = loop_prim + "_" + unique_id;
+        }
+    }
 
 protected:
-    std::string unique_id;
+    std::string unique_id = "";
 
     std::shared_ptr<primitive> desc;
     program& myprog;

src/plugins/intel_gpu/src/graph/kernel_selector_helper.cpp

@@ -839,7 +839,7 @@ void set_params(const program_node& node, kernel_selector::params& params) {
     const auto& program = node.get_program();
     const auto& device_info = program.get_engine().get_device_info();
 
-    params.uniqueID = std::to_string(program.get_id()) + "_"  + node.get_unique_id();
+    params.uniqueID = node.get_unique_id();
     params.engineInfo.bSubGroupSupport = device_info.supports_subgroups;
     params.engineInfo.bSubGroupShortSupport = device_info.supports_subgroups_short;
     params.engineInfo.bSubGroupCharSupport = device_info.supports_subgroups_char;

src/plugins/intel_gpu/src/graph/program.cpp

@@ -94,13 +94,13 @@ program::program(engine& engine_ref,
                  build_options const& options,
                  bool is_internal,
                  bool no_optimizations,
-                 bool is_body_program)
+                 primitive_id parent_id)
     : _engine(engine_ref),
       _stream(_engine.create_stream()),
       options(options),
       processing_order(),
       tuning_cache(nullptr),
-      is_body_program(is_body_program) {
+      parent_primitive(parent_id) {
     init_primitives();
     set_options();
     pm = std::unique_ptr<pass_manager>(new pass_manager(*this));
@@ -180,8 +180,8 @@ program::ptr program::build_program(engine& engine,
                                     const build_options& options,
                                     bool is_internal,
                                     bool no_optimizations,
-                                    bool is_body_program) {
-    return std::make_shared<program>(engine, topology, options, is_internal, no_optimizations, is_body_program);
+                                    primitive_id parent_id) {
+    return std::make_shared<program>(engine, topology, options, is_internal, no_optimizations, parent_id);
 }
 
 program::ptr program::build_program(engine& engine,

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

@@ -3,7 +3,6 @@
 //
 
 #include "program_node.h"
-#include "intel_gpu/graph/program.hpp"
 #include "program_helpers.h"
 #include "primitive_inst.h"