[GPU] Fix performance degradation in flux.1-schnell (openvinotoolkit#32612)

### Details:
- Performance degradation in `flux.1-schnell` caused by
[PR#32386](openvinotoolkit#32386).
- Resolved by not using onednn when feature isn't aligned for
concatenation.

Author: davidsnam-intel

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

@@ -59,31 +59,6 @@ void basic_memory_dependencies::run(program& p) {
                     }
                 }
             }
-
-            // onednn concatenation doesn't support non-zero padding which can occur for unaligned feature.
-            if (node->is_type<concatenation>()) {
-                auto is_feature_aligned = [](const cldnn::layout& l) {
-                    if (!format::is_blocked(l.format)) {
-                        return true;
-                    }
-
-                    const auto& order = format::internal_order(l.format);
-                    int f_bs = 1;
-                    for (const auto& [dim, bs] : format::block_sizes(l.format)) {
-                        if (dim < order.size() && order[dim] == 'f') {
-                            f_bs = bs;
-                        }
-                    }
-                    return l.feature() % f_bs == 0;
-                };
-
-                if (node->is_dynamic() || (!node->is_dynamic() && !is_feature_aligned(node->get_output_layout()))) {
-                    node->can_share_buffer(false);
-                    for (auto& dep : node->get_dependencies()) {
-                        dep.first->can_share_buffer(false);
-                    }
-                }
-            }
         }
 
         // Note we iterate over processing order, it means if primitve has processing num greater than any of outputs,

src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.hpp

@@ -54,6 +54,36 @@ struct ConcatenationImplementationManager : public ImplementationManager {
         if (out_layout.data_padding)
             return false;
 
+        auto is_feature_aligned = [](const layout& l) {
+            if (!format::is_blocked(l.format))
+                return true;
+
+            const auto& order = format::internal_order(l.format);
+            const size_t feature_dim_idx = order.find('f');
+            if (feature_dim_idx == std::string::npos)
+                return true;
+
+            auto feature_dim = l.get_partial_shape()[feature_dim_idx];
+            if (feature_dim.is_dynamic())
+                return false;
+
+            const auto& block_sizes = format::block_sizes(l.format);
+            auto block_it = std::find_if(block_sizes.begin(), block_sizes.end(), [&](const auto& block) {
+                return block.first == feature_dim_idx;
+            });
+
+            if (block_it == block_sizes.end())
+                return true;
+
+            const int feature_block_size = block_it->second;
+            return feature_dim.get_length() % feature_block_size == 0;
+        };
+
+        // onednn concatenation doesn't support non-zero padding which can occur for unaligned feature.
+        if (!is_feature_aligned(out_layout)) {
+            return false;
+        }
+
         const auto& concat_node = node.as<concatenation>();
         auto concat_axis = concat_node.get_primitive()->axis;
 

src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp

@@ -1666,6 +1666,41 @@ TEST(concat_gpu_onednn, basic_input_types) {
     }
 }
 
+TEST(concat_gpu_onednn, impl_selection_unaligned_feature_axis) {
+    auto& engine = get_test_engine();
+    if (!engine.get_device_info().supports_immad)
+        return;
+
+    layout in_layout = { data_types::f16, format::b_fs_yx_fsv16, { 1, 18, 2, 2 } };
+    auto input0 = engine.allocate_memory(in_layout);
+    auto input1 = engine.allocate_memory(in_layout);
+
+    topology topology(
+            input_layout("input0", in_layout),
+            input_layout("input1", in_layout),
+            concatenation("concat",
+                          { input_info("input0"), input_info("input1") },
+                          1,
+                          data_types::f16)
+    );
+
+    ExecutionConfig config = get_test_default_config(engine);
+    config.set_property(ov::intel_gpu::optimize_data(true));
+
+    network network(engine, topology, config);
+    network.set_input_data("input0", input0);
+    network.set_input_data("input1", input1);
+
+    auto concat_inst = network.get_primitive("concat");
+    auto impl = concat_inst->get_impl();
+    ASSERT_TRUE(impl != nullptr);
+    ASSERT_TRUE(impl->m_manager != nullptr);
+    EXPECT_EQ(impl->m_manager->get_impl_type(), impl_types::ocl);
+    EXPECT_FALSE(impl->is_onednn());
+
+    ASSERT_NO_THROW(network.execute());
+}
+
 TEST(concat_gpu_onednn, b_fs_yx_fsv16_input_types) {
     auto& engine = get_test_engine();
     if (!engine.get_device_info().supports_immad)