WIP: [GPU] PagedAttention initial impl

Author: sshlyapn

src/plugins/intel_gpu/include/intel_gpu/plugin/program_builder.hpp

@@ -172,6 +172,7 @@ class ProgramBuilder final {
     void CreateSingleLayerPrimitive(cldnn::topology& topology, const std::shared_ptr<ov::Node>& op);
 };
 
+void CreatePagedAttention(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op);
 void CreateCustomOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& node, CustomLayerPtr customLayer);
 void CreateUnaryEltwiseOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& node,
                           cldnn::activation_func func, cldnn::activation_additional_params params);

src/plugins/intel_gpu/include/intel_gpu/primitives/paged_attention.hpp

@@ -0,0 +1,39 @@
+// Copyright (C) 2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+#include "primitive.hpp"
+#include "intel_gpu/graph/program.hpp"
+
+#include <vector>
+
+namespace cldnn {
+
+struct paged_attention : public primitive_base<paged_attention> {
+    CLDNN_DECLARE_PRIMITIVE(paged_attention)
+
+    paged_attention() : primitive_base("", {}) {}
+
+    paged_attention(const primitive_id& id,
+                    const std::vector<input_info>& inputs,
+                    const padding& output_padding = padding())
+        : primitive_base(id, inputs, {output_padding}) {
+            OPENVINO_ASSERT(inputs.size() == 13, "[GPU] Unexpected inputs number for PagedAttention primitive: ", inputs.size());
+    }
+
+    bool operator==(const primitive& rhs) const override {
+        return compare_common_params(rhs);
+    }
+
+    void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<paged_attention>::save(ob);
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        primitive_base<paged_attention>::load(ib);
+    }
+
+    std::shared_ptr<cldnn::program> prefill_stage;
+};
+}  // namespace cldnn

src/plugins/intel_gpu/src/graph/graph_optimizer/compile_graph.cpp

@@ -34,10 +34,7 @@ void compile_graph::run(program& p) {
         }
     }
 
-    auto task_executor = p.get_task_executor();
     auto& proc_order = p.get_processing_order();
-    std::vector<ov::threading::Task> tasks;
-    std::exception_ptr exception;
     for (size_t idx = 0; idx < proc_order.size(); idx++) {
         auto& node = *(std::next(proc_order.begin(), idx));
         const bool use_shape_agnostic_impl = !p.get_config().get_property(ov::intel_gpu::use_only_static_kernels_for_dynamic_shape);
@@ -79,29 +76,30 @@ void compile_graph::run(program& p) {
             can_select_impl = true;
 
         if (can_select_impl) {
-            tasks.push_back([node, &exception, change_initial_impl, original_impl_type] {
                 try {
+                    std::exception_ptr curr_excp;
                     node->selected_impl = node->type()->choose_impl(*node);
                     if (change_initial_impl) {
                         GPU_DEBUG_TRACE_DETAIL << node->id() << ": use " << node->get_preferred_impl_type()
                                                << " as initial impl instead of " << original_impl_type << std::endl;
                         node->set_preferred_impl_type(original_impl_type);
                     }
                 } catch(...) {
-                    exception = std::current_exception();
+                    try {
+                        std::exception_ptr curr_excp;
+                        if (curr_excp = std::current_exception())
+                        {
+                            std::rethrow_exception(curr_excp);
+                        }
+                    } catch (const std::exception& e) {
+                        std::cerr << "Can't compile " << node->id() << ", error " << e.what() << "\n";
+                    }
                 }
-            });
         } else {
             if (change_initial_impl) {
                 node->set_preferred_impl_type(original_impl_type);
             }
         }
     }
 
-    task_executor->run_and_wait(tasks);
-    tasks.clear();
-
-    if (exception) {
-        std::rethrow_exception(exception);
-    }
 }

src/plugins/intel_gpu/src/graph/graph_optimizer/mark_runtime_skippable_nodes.cpp

@@ -40,6 +40,7 @@ void mark_runtime_skippable_nodes::run(program& p) {
             }
         });
         program_helpers::do_for_types<permute>(*node, [](permute_node& node){
+            return;
             auto impl_params = node.get_kernel_impl_params();
             if (node.is_output() ||
                 node.has_fused_primitives() ||