[GPU] Update internal buffers interface, add BufferDescriptor struct for internal buffers description

sshlyapn · sshlyapn · commit 62e668ad7ae5 · 2025-03-04T11:37:24.000+04:00
diff --git a/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp b/src/plugins/intel_gpu/src/graph/impls/common/wait_for_events.cpp
@@ -32,7 +32,7 @@ class wait_for_events_impl : public primitive_impl {
     void init_kernels(const kernels_cache&, const kernel_impl_params&) override {}
     void set_arguments(primitive_inst& /*instance*/) override {}
     void set_arguments(primitive_inst& /*instance*/, kernel_arguments_data& /*args*/) override {}
-    std::vector<layout> get_internal_buffer_layouts() const override { return {}; }
+    std::vector<BufferDescriptor> get_internal_buffer_descs(const kernel_impl_params&) const override { return {}; }
 
     event::ptr execute(const std::vector<event::ptr>& events, primitive_inst& instance) override {
         auto& stream = instance.get_network().get_stream();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/border.cpp
@@ -150,17 +150,17 @@ struct border_impl : typed_primitive_impl_ocl<border> {
         return args;
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         const auto& prim_params = static_cast<const kernel_selector::border_params&>(*_kernel_data.params);
-        std::vector<layout> layouts;
+        std::vector<BufferDescriptor> internal_buffers;
 
         if ((_kernel_data.params == nullptr && zero_input) ||
             (_kernel_data.params != nullptr && prim_params.inputs[0].LogicalSize() == 0)) {
             layout any_layout = {data_types::u8, format::bfyx, {1, 1, 1, 1}};
-            layouts.push_back(any_layout);
+            internal_buffers.emplace_back(any_layout);
         }
 
-        return layouts;
+        return internal_buffers;
     }
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/multi_stage_primitive.hpp b/src/plugins/intel_gpu/src/graph/impls/ocl/multi_stage_primitive.hpp
@@ -157,8 +157,8 @@ struct multi_stage_primitive : public typed_primitive_impl<PType> {
         return _kernels;
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
-        std::vector<layout> layouts;
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
+        std::vector<BufferDescriptor> internal_buffers;
         for (auto& kd : _kernels_data) {
             if (kd.internalBuffers.empty())
                 continue;
@@ -168,10 +168,10 @@ struct multi_stage_primitive : public typed_primitive_impl<PType> {
             for (const auto& buffer : kd.internalBuffers) {
                 layout inbuf_layout = {dtype, format::bfyx, // simple linear format (flattern to x channel)
                                         {1, 1, 1, (tensor::value_type)(buffer.byte_count / bpp)}};
-                layouts.push_back(inbuf_layout);
+                internal_buffers.emplace_back(inbuf_layout, buffer.lockable);
             }
         }
-        return layouts;
+        return internal_buffers;
     }
 
     void set_arguments_impl(typed_primitive_inst<PType>& instance) override {
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/paged_attention.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/paged_attention.cpp
@@ -141,7 +141,7 @@ struct paged_attention_impl : multi_stage_primitive<paged_attention> {
         ob << make_data(&use_micro_sdpa, sizeof(bool));
     }
 
-    std::vector<kernel_selector::InternalBuffer> get_internal_buffers_desc() const {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         /*
         * Internal buffers allocation owners and users:
         * +--------------------------------------+--------------------+--------------------+
@@ -181,12 +181,16 @@ struct paged_attention_impl : multi_stage_primitive<paged_attention> {
         *           Filled in paged_attention_inst::on_execute() call for sdpa-micro kernel only.
         */
 
-        auto add_internal_buffers = [](std::vector<kernel_selector::InternalBuffer>& internal_buffers,
+        auto add_internal_buffers = [](std::vector<BufferDescriptor>& internal_buffers,
                                        const kernel_selector::KernelData& kd) {
-            internal_buffers.insert(internal_buffers.end(), kd.internalBuffers.begin(), kd.internalBuffers.end());
+            for (const auto& buffer_desc : kd.internalBuffers) {
+                internal_buffers.emplace_back(
+                    layout{ov::PartialShape{static_cast<int64_t>(buffer_desc.byte_count)}, ov::element::u8, format::bfyx},
+                    buffer_desc.lockable);
+            }
         };
 
-        std::vector<kernel_selector::InternalBuffer> internal_buffers;
+        std::vector<BufferDescriptor> internal_buffers;
         add_internal_buffers(internal_buffers, _kernels_data[Stage::KV_CACHE_UPDATE]);
         add_internal_buffers(internal_buffers, _kernels_data[Stage::PA_SDPA]);
 
@@ -196,15 +200,6 @@ struct paged_attention_impl : multi_stage_primitive<paged_attention> {
         return internal_buffers;
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
-        std::vector<layout> layouts;
-
-        for (const auto& buffer : get_internal_buffers_desc())
-            layouts.emplace_back(ov::PartialShape{static_cast<int64_t>(buffer.byte_count)}, ov::element::u8, format::bfyx);
-
-        return layouts;
-    }
-
     kernel_arguments_data get_arguments(const paged_attention_inst& instance, size_t stage, size_t kernel_idx, bool is_mixed_mode) const {
         const auto desc = instance.get_node().as<paged_attention>().get_primitive();
 
@@ -298,18 +293,6 @@ struct paged_attention_impl : multi_stage_primitive<paged_attention> {
         return args;
     }
 
-    std::set<size_t> get_lockable_internal_buffers() const override {
-        std::set<size_t> lockable_ids;
-        const auto& internal_buffers = get_internal_buffers_desc();
-        for (size_t i = 0; i < internal_buffers.size(); i++) {
-            if (internal_buffers[i].lockable) {
-                lockable_ids.insert(i);
-            }
-        }
-
-        return lockable_ids;
-    };
-
     void prepare_internal_buffers(paged_attention_inst& instance, const PagedAttentionStage& stage) {
         const auto& desc = instance.get_impl_params()->typed_desc<paged_attention>();
         const bool has_scores_output = desc->has_scores_output();
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp b/src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp
@@ -184,19 +184,19 @@ struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
         return _kernels;
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         if (_kernel_data.internalBuffers.empty())
             return {};
 
-        std::vector<layout> layouts;
+        std::vector<BufferDescriptor> internal_buffers;
         auto dtype = from_data_type(_kernel_data.internalBufferDataType);
         const auto bpp = data_type_traits::size_of(dtype);
         for (const auto& buffer : _kernel_data.internalBuffers) {
             layout inbuf_layout = {dtype, format::bfyx, // simple linear format (flattern to x channel)
                                     {1, 1, 1, (tensor::value_type)(buffer.byte_count / bpp)}};
-            layouts.push_back(inbuf_layout);
+            internal_buffers.emplace_back(inbuf_layout, buffer.lockable);
         }
-        return layouts;
+        return internal_buffers;
     }
 
     void set_arguments_impl(typed_primitive_inst<PType>& instance) override {
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/scaled_dot_product_attention.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/scaled_dot_product_attention.cpp
@@ -56,7 +56,7 @@ struct scaled_dot_product_attention_impl : multi_stage_primitive<scaled_dot_prod
     }
 
 protected:
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         // Look for the first sdpa_opt kernel entry. Currently, it can be used as default sdpa, indirect sdpa, or for both default
         // and indirect cases. All of sdpa_opt kernels use the same internal buffers, so we can find the first sdpa_opt and
         // use its` internal buffers configuration. The following scenarios are possible:
@@ -77,18 +77,18 @@ struct scaled_dot_product_attention_impl : multi_stage_primitive<scaled_dot_prod
             kernel_idx = 1;
         }
 
-        std::vector<layout> layouts;
+        std::vector<BufferDescriptor> internal_buffers;
         if (kernel_idx < _kernels_data.size()) {
             auto dtype = from_data_type(_kernels_data[kernel_idx].internalBufferDataType);
             const auto bpp = data_type_traits::size_of(dtype);
             for (const auto& buffer : _kernels_data[kernel_idx].internalBuffers) {
                 layout inbuf_layout = {dtype, format::bfyx, // simple linear format (flattern to x channel)
                                         {1, 1, 1, (tensor::value_type)(buffer.byte_count / bpp)}};
-                layouts.push_back(inbuf_layout);
+                internal_buffers.emplace_back(inbuf_layout, buffer.lockable);
             }
         }
 
-        return layouts;
+        return internal_buffers;
     }
 
     static size_t get_beam_table_id(std::shared_ptr<const scaled_dot_product_attention> primitive) {
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h b/src/plugins/intel_gpu/src/graph/impls/onednn/primitive_onednn_base.h
@@ -572,10 +572,12 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl<PType> {
         return event;
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         if (_scratchpad_md.get_size() == 0)
             return {};
-        return {{{1, 1, 1, (tensor::value_type)(_scratchpad_md.get_size())}, cldnn::data_types::u8, format::bfyx}};
+        return {BufferDescriptor({ov::PartialShape{static_cast<int64_t>(_scratchpad_md.get_size())},
+                                  cldnn::data_types::u8,
+                                  format::bfyx})};
     }
 };
 
diff --git a/src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h b/src/plugins/intel_gpu/src/graph/impls/sycl/primitive_sycl_base.h
@@ -51,7 +51,7 @@ struct typed_primitive_sycl_impl : public typed_primitive_impl<PType> {
         }
     }
 
-    std::vector<layout> get_internal_buffer_layouts_impl() const override {
+    std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {
         return {};
     }
 };
diff --git a/src/plugins/intel_gpu/src/graph/include/primitive_inst.h b/src/plugins/intel_gpu/src/graph/include/primitive_inst.h
@@ -42,6 +42,7 @@ template <class PType>
 class typed_primitive_inst;
 
 struct ImplementationManager;
+struct BufferDescriptor;
 
 /*
     Base class for all implementations.
@@ -55,8 +56,7 @@ struct primitive_impl {
         primitive_impl(nullptr, std::move(kernel_name), is_dynamic) {}
     virtual ~primitive_impl() = default;
 
-    virtual std::vector<layout> get_internal_buffer_layouts() const = 0;
-    virtual std::set<size_t> get_lockable_internal_buffers() const { return {}; }
+    virtual std::vector<BufferDescriptor> get_internal_buffer_descs(const kernel_impl_params& impl_params) const = 0;
     virtual void set_node_params(const program_node&) {}
     virtual const std::string& get_type_info() const = 0;
     virtual void set_arguments(primitive_inst& instance) = 0;
@@ -148,6 +148,12 @@ struct ImplementationsFactory {
     bool has(impl_types impl_type) const;
 };
 
+struct BufferDescriptor {
+    explicit BufferDescriptor(const layout& l, bool lockable = false) : m_lockable(lockable), m_layout(l) {}
+    bool m_lockable = false;
+    layout m_layout;
+};
+
 /*
     Base class for all primitive instances.
     It's main responsibility is to allocate memory required to run single, specified in ctor,
@@ -515,11 +521,11 @@ struct typed_primitive_impl : public primitive_impl {
         return execute_impl(event, reinterpret_cast<typed_primitive_inst<PType>&>(instance));
     }
 
-    std::vector<layout> get_internal_buffer_layouts() const override {
-        return get_internal_buffer_layouts_impl();
+    std::vector<BufferDescriptor> get_internal_buffer_descs(const kernel_impl_params& impl_params) const override {
+        return get_internal_buffer_descs_impl(impl_params);
     }
 
-    virtual std::vector<layout> get_internal_buffer_layouts_impl() const {
+    virtual std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const {
         return {};
     }
 
diff --git a/src/plugins/intel_gpu/src/graph/primitive_inst.cpp b/src/plugins/intel_gpu/src/graph/primitive_inst.cpp
@@ -1046,34 +1046,33 @@ void primitive_inst::realloc_if_needed(bool prev_execution_skipped) {
     {
         if (_impl == nullptr)
             return;
-        const auto& ibuf_layouts = _impl->get_internal_buffer_layouts();
-        if (ibuf_layouts.empty())
+        const auto& buffer_descs = _impl->get_internal_buffer_descs(*_impl_params);
+        if (buffer_descs.empty())
             return;
         GPU_DEBUG_CODE(std::string memalloc_info = "");
-        const auto& lockable_buffers_indexes = _impl->get_lockable_internal_buffers();
-        for (size_t i = 0; i < ibuf_layouts.size(); ++i) {
-            auto need_lockable = lockable_buffers_indexes.find(i) != lockable_buffers_indexes.end();
+        for (size_t i = 0; i < buffer_descs.size(); ++i) {
+            auto need_lockable = buffer_descs[i].m_lockable;
             auto alloc_type = i < _intermediates_memory.size() ? _intermediates_memory[i]->get_allocation_type()
                                                                : allocation_type::unknown;
             bool can_reuse = true;
             can_reuse &= alloc_type != allocation_type::unknown &&
-                         ibuf_layouts[i].bytes_count() <= max_intermediates_memory_sizes[i];
+                         buffer_descs[i].m_layout.bytes_count() <= max_intermediates_memory_sizes[i];
             can_reuse &= (need_lockable && alloc_type != cldnn::allocation_type::usm_device) ||
                          (!need_lockable && alloc_type != cldnn::allocation_type::usm_host);
 
             if (can_reuse) {
-                _intermediates_memory[i] = _network.get_engine().reinterpret_buffer(*_intermediates_memory[i], ibuf_layouts[i]);
+                _intermediates_memory[i] = _network.get_engine().reinterpret_buffer(*_intermediates_memory[i], buffer_descs[i].m_layout);
                GPU_DEBUG_CODE(memalloc_info += ((_intermediates_memory.size() > 1) ? ("i" + to_string(i) + ":") : "") + "reuse_buffer");
             } else {
                 // TODO: If there is a kernel which requires reset internal buffer in the future,
                 // we'll need additional handle for that purpose like need_reset_output_memory
                 const bool need_reset = false;
                 if (i < _intermediates_memory.size()) {
-                    _intermediates_memory[i] = allocate_internal_buffer(ibuf_layouts[i], i, need_reset, need_lockable);
+                    _intermediates_memory[i] = allocate_internal_buffer(buffer_descs[i].m_layout, i, need_reset, need_lockable);
                     max_intermediates_memory_sizes[i] = _intermediates_memory[i]->size();
                 } else {
                     // i-th layout has not been allocated yet
-                    _intermediates_memory.push_back(allocate_internal_buffer(ibuf_layouts[i], i, need_reset, need_lockable));
+                    _intermediates_memory.push_back(allocate_internal_buffer(buffer_descs[i].m_layout, i, need_reset, need_lockable));
                     max_intermediates_memory_sizes.push_back(_intermediates_memory[i]->size());
                 }
                 GPU_DEBUG_CODE(memalloc_info +=
@@ -2207,16 +2206,16 @@ memory::ptr primitive_inst::allocate_internal_buffer(const layout& layout, size_
 void primitive_inst::allocate_internal_buffers(bool reset) {
     if (_impl == nullptr || _outputs.empty() || _outputs[0] == nullptr)
         return;
-    const auto& ibuf_layouts = _impl->get_internal_buffer_layouts();
-    if (ibuf_layouts.empty())
+    const auto& buffer_descs = _impl->get_internal_buffer_descs(*_impl_params);
+    if (buffer_descs.empty())
         return;
 
     // allocate intermediate memory for the updated layout of buffer
     std::vector<memory::ptr> intermediates_memory;
-    for (size_t i = 0; i < ibuf_layouts.size(); ++i) {
-        if (ibuf_layouts[i].get_linear_size() == 0)
+    for (size_t i = 0; i < buffer_descs.size(); ++i) {
+        if (buffer_descs[i].m_layout.get_linear_size() == 0)
             continue;
-        intermediates_memory.push_back(allocate_internal_buffer(ibuf_layouts[i], i, reset));
+        intermediates_memory.push_back(allocate_internal_buffer(buffer_descs[i].m_layout, i, reset));
         max_intermediates_memory_sizes.push_back(intermediates_memory[i]->size());
     }
     _intermediates_memory = intermediates_memory;

Original file line number	Diff line number	Diff line change
`@@ -150,17 +150,17 @@ struct border_impl : typed_primitive_impl_ocl<border> {`
`150`	`150`	`return args;`
`151`	`151`	`}`
`152`	`152`
`153`		`- std::vector<layout> get_internal_buffer_layouts_impl() const override {`
	`153`	`+ std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {`
`154`	`154`	`const auto& prim_params = static_cast<const kernel_selector::border_params&>(*_kernel_data.params);`
`155`		`- std::vector<layout> layouts;`
	`155`	`+ std::vector<BufferDescriptor> internal_buffers;`
`156`	`156`
`157`	`157`	`if ((_kernel_data.params == nullptr && zero_input) \|\|`
`158`	`158`	`(_kernel_data.params != nullptr && prim_params.inputs[0].LogicalSize() == 0)) {`
`159`	`159`	`layout any_layout = {data_types::u8, format::bfyx, {1, 1, 1, 1}};`
`160`		`- layouts.push_back(any_layout);`
	`160`	`+ internal_buffers.emplace_back(any_layout);`
`161`	`161`	`}`
`162`	`162`
`163`		`- return layouts;`
	`163`	`+ return internal_buffers;`
`164`	`164`	`}`
`165`	`165`	`};`
`166`	`166`
Original file line number	Diff line number	Diff line change
`@@ -157,8 +157,8 @@ struct multi_stage_primitive : public typed_primitive_impl<PType> {`
`157`	`157`	`return _kernels;`
`158`	`158`	`}`
`159`	`159`
`160`		`- std::vector<layout> get_internal_buffer_layouts_impl() const override {`
`161`		`- std::vector<layout> layouts;`
	`160`	`+ std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {`
	`161`	`+ std::vector<BufferDescriptor> internal_buffers;`
`162`	`162`	`for (auto& kd : _kernels_data) {`
`163`	`163`	`if (kd.internalBuffers.empty())`
`164`	`164`	`continue;`
`@@ -168,10 +168,10 @@ struct multi_stage_primitive : public typed_primitive_impl<PType> {`
`168`	`168`	`for (const auto& buffer : kd.internalBuffers) {`
`169`	`169`	`layout inbuf_layout = {dtype, format::bfyx, // simple linear format (flattern to x channel)`
`170`	`170`	`{1, 1, 1, (tensor::value_type)(buffer.byte_count / bpp)}};`
`171`		`- layouts.push_back(inbuf_layout);`
	`171`	`+ internal_buffers.emplace_back(inbuf_layout, buffer.lockable);`
`172`	`172`	`}`
`173`	`173`	`}`
`174`		`- return layouts;`
	`174`	`+ return internal_buffers;`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`void set_arguments_impl(typed_primitive_inst<PType>& instance) override {`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ struct scaled_dot_product_attention_impl : multi_stage_primitive<scaled_dot_prod`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`protected:`
`59`		`- std::vector<layout> get_internal_buffer_layouts_impl() const override {`
	`59`	`+ std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {`
`60`	`60`	`// Look for the first sdpa_opt kernel entry. Currently, it can be used as default sdpa, indirect sdpa, or for both default`
`61`	`61`	`// and indirect cases. All of sdpa_opt kernels use the same internal buffers, so we can find the first sdpa_opt and`
`62`	`62`	// use its` internal buffers configuration. The following scenarios are possible:
`@@ -77,18 +77,18 @@ struct scaled_dot_product_attention_impl : multi_stage_primitive<scaled_dot_prod`
`77`	`77`	`kernel_idx = 1;`
`78`	`78`	`}`
`79`	`79`
`80`		`- std::vector<layout> layouts;`
	`80`	`+ std::vector<BufferDescriptor> internal_buffers;`
`81`	`81`	`if (kernel_idx < _kernels_data.size()) {`
`82`	`82`	`auto dtype = from_data_type(_kernels_data[kernel_idx].internalBufferDataType);`
`83`	`83`	`const auto bpp = data_type_traits::size_of(dtype);`
`84`	`84`	`for (const auto& buffer : _kernels_data[kernel_idx].internalBuffers) {`
`85`	`85`	`layout inbuf_layout = {dtype, format::bfyx, // simple linear format (flattern to x channel)`
`86`	`86`	`{1, 1, 1, (tensor::value_type)(buffer.byte_count / bpp)}};`
`87`		`- layouts.push_back(inbuf_layout);`
	`87`	`+ internal_buffers.emplace_back(inbuf_layout, buffer.lockable);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`- return layouts;`
	`91`	`+ return internal_buffers;`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`static size_t get_beam_table_id(std::shared_ptr<const scaled_dot_product_attention> primitive) {`
Original file line number	Diff line number	Diff line change
`@@ -572,10 +572,12 @@ struct typed_primitive_onednn_impl : public typed_primitive_impl<PType> {`
`572`	`572`	`return event;`
`573`	`573`	`}`
`574`	`574`
`575`		`- std::vector<layout> get_internal_buffer_layouts_impl() const override {`
	`575`	`+ std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {`
`576`	`576`	`if (_scratchpad_md.get_size() == 0)`
`577`	`577`	`return {};`
`578`		`- return {{{1, 1, 1, (tensor::value_type)(_scratchpad_md.get_size())}, cldnn::data_types::u8, format::bfyx}};`
	`578`	`+ return {BufferDescriptor({ov::PartialShape{static_cast<int64_t>(_scratchpad_md.get_size())},`
	`579`	`+ cldnn::data_types::u8,`
	`580`	`+ format::bfyx})};`
`579`	`581`	`}`
`580`	`582`	`};`
`581`	`583`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ struct typed_primitive_sycl_impl : public typed_primitive_impl<PType> {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`- std::vector<layout> get_internal_buffer_layouts_impl() const override {`
	`54`	`+ std::vector<BufferDescriptor> get_internal_buffer_descs_impl(const kernel_impl_params&) const override {`
`55`	`55`	`return {};`
`56`	`56`	`}`
`57`	`57`	`};`