[GPU] Add weight size limit for conv opt kernels

Author: kelvinchoi-intel

src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_bfyx_gemm_like.cpp

@@ -110,6 +110,12 @@ bool ConvolutionKernel_bfyx_GEMMLike::Validate(const Params& p) const {
         return false;
     }
 
+    // To prevent big sized filter which causes lots of CL build time.
+    const size_t acceptable_filter_x_size = 64;     // This acceptable size was decided by heuristics
+    if (params.filterSize.x > acceptable_filter_x_size) {
+        return false;
+    }
+
     return true;
 }
 

src/plugins/intel_gpu/src/kernel_selector/kernels/convolution/convolution_kernel_bfyx_os_iyx_osv16.cpp

@@ -205,6 +205,14 @@ bool ConvolutionKernel_bfyx_os_iyx_osv16::Validate(const Params& p) const {
         return false;
     }
 
+    // To prevent big sized filter which causes lots of CL build time.
+    const size_t acceptable_filter_size = 1024;     // This acceptable size was decided by heuristics
+    const auto& params = static_cast<const convolution_params&>(p);
+    auto filter_size = params.filterSize.x * params.filterSize.y;
+    if (filter_size > acceptable_filter_size) {
+        return false;
+    }
+
     return true;
 }
 

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

@@ -1638,6 +1638,83 @@ TEST(convolution_f32_fw_gpu, basic_convolution) {
     }
 }
 
+TEST(convolution_f32_fw_gpu, convolution_big_size_weights) {
+    auto& engine = get_test_engine();
+
+    const std::vector<int> filter_size_data = {
+        65, 65,
+    };
+
+    const std::vector<std::string> impl_kernel_data = {
+        "convolution_gpu_ref__f32"
+    };
+
+    for (size_t m = 0 ; m < filter_size_data.size() / 2; m++) {
+        const int in_y = filter_size_data[m * 2];
+        const int in_x = filter_size_data[m * 2 + 1];
+
+        auto input = engine.allocate_memory({ data_types::f32, format::yxfb, { 1, 1, in_y, in_x } });
+        auto weights = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, in_y, in_x } });
+        auto biases = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, 1, 1 } });
+
+        tests::random_generator rg(GET_SUITE_NAME);
+        VVVVF<float> input_rnd = rg.generate_random_4d<float>(1, 1, in_y, in_x, -10, 10);
+        VF<float> input_rnd_vec = flatten_4d<float>(format::yxfb, input_rnd);
+        VVVVF<float> filter_rnd = rg.generate_random_4d<float>(1, 1, in_y, in_x, -10, 10);
+        VF<float> filter_rnd_vec = flatten_4d<float>(format::bfyx, filter_rnd);
+
+        set_values(biases, { 0.0f });
+        set_values(input, input_rnd_vec);
+        set_values(weights, filter_rnd_vec);
+
+        float output_sum = 0.f;
+        size_t idx = 0;
+        for (int i = 0 ; i < in_y; i++) {
+            for (int k = 0 ; k < in_x; k++) {
+                idx = i * in_x + k;
+                output_sum += input_rnd_vec[idx] * filter_rnd_vec[idx];
+            }
+        }
+
+        topology topology(
+            input_layout("input", input->get_layout()),
+            data("weights", weights),
+            data("biases", biases),
+            convolution( "conv", input_info("input"), "weights", "biases", 1, {1, 1}, {1, 1}, {0, 0}, {0, 0}, false));
+
+        ExecutionConfig config = get_test_default_config(engine);
+        config.set_property(ov::intel_gpu::optimize_data(true));
+
+        network network(engine, topology, config);
+
+        auto impl_info = network.get_implementation_info("conv");
+        ASSERT_EQ(impl_info, impl_kernel_data[m]);
+
+        network.set_input_data("input", input);
+
+        auto outputs = network.execute();
+        ASSERT_EQ(outputs.size(), size_t(1));
+        ASSERT_EQ(outputs.begin()->first, "conv");
+
+        auto output_memory = outputs.at("conv").get_memory();
+        auto output_layout = output_memory->get_layout();
+        cldnn::mem_lock<float> output_ptr(output_memory, get_test_stream());
+
+        int y_size = output_layout.spatial(1);
+        int x_size = output_layout.spatial(0);
+        int f_size = output_layout.feature();
+        int b_size = output_layout.batch();
+
+        ASSERT_EQ(y_size, 1);
+        ASSERT_EQ(x_size, 1);
+        ASSERT_EQ(f_size, 1);
+        ASSERT_EQ(b_size, 1);
+
+        ASSERT_EQ(output_sum, output_ptr[0]);
+    }
+
+}
+
 TEST(convolution_f32_fw_gpu, basic_convolution_bfyx_weights_as_input_layout) {
     //Same params as convolution_f32_fw_gpu, basic_convolution but with bfyx optimized data and weights set as input_layout
     auto& engine = get_test_engine();