mlukasze · August 28, 2026 07:21
diff --git a/GPU_PERF_ANALYSIS_REPORT.md b/GPU_PERF_ANALYSIS_REPORT.md
diff --git a/vram_pressure_diagnostic.patch b/vram_pressure_diagnostic.patch
 diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
 index ac09b4e6c7..732c945f91 100644
 --- a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
 +++ b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
 @@ -280,6 +280,33 @@ public:
     // returns {-1, -1} if it failed to estimate by allocating given batch size
     std::pair<int64_t/*const alloc*/, int64_t/*general alloc*/> get_estimated_device_mem_usage();
 
 +    // Returns true if `total_weights_bytes` (the total size of constants/weights that need to be
 +    // device-resident) is within `margin_ratio` of, or exceeds, `device_max_global_mem_bytes` (the
 +    // device's *physical* memory capacity, i.e. device_info::max_global_mem_size -- NOT
 +    // engine::get_max_memory_size(), which also folds in host RAM and is only meant as a last-resort
 +    // guard against being killed by the Linux OOM-killer, not a VRAM-capacity check).
 +    //
 +    // Once a model's resident weights approach or exceed physical device memory, the device/driver is
 +    // forced into a memory-oversubscription regime (host-visible fallback allocations, eviction/paging)
 +    // that remains functionally correct but can be catastrophically slower (up to ~75x observed in
 +    // practice for a hybrid-attention LLM whose INT8 weights slightly exceeded a 24GB GPU's VRAM, while
 +    // the same model's INT4 weights fit comfortably and ran at expected speed) -- see
 +    // openvinotoolkit/omega#66 for the investigation that motivated this diagnostic.
 +    //
 +    // This is a pure, side-effect-free helper (no device/engine access) so it can be exercised directly
 +    // by unit tests without requiring a real GPU device.
 +    static bool is_device_memory_pressure_risk(uint64_t total_weights_bytes,
 +                                                uint64_t device_max_global_mem_bytes,
 +                                                double margin_ratio = 0.9);
 +
 +    // Computes the total size of constants/weights in this program and, if it is within margin_ratio of
 +    // or exceeds the device's physical memory capacity, logs a clear, user-visible warning (independent
 +    // of ENABLE_DEBUG_CAPS / OV_VERBOSE, since this class of failure otherwise produces either a hard,
 +    // hard-to-diagnose driver error, or -- on platforms where the driver falls back to a slow oversubscribed
 +    // path -- no diagnostic output at all in a release build). Purely informational: never alters
 +    // allocation, execution, or numerical behavior.
 +    void check_device_memory_pressure();
 +
     using ImplementationsCache = cldnn::LruCacheThreadSafe<kernel_impl_params, std::shared_ptr<primitive_impl>, kernel_impl_params::Hasher>;
 
     ImplementationsCache& get_implementations_cache() const { return *_impls_cache; }
 diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp
 index 9c7650872a..4feb826f32 100644
 --- a/src/plugins/intel_gpu/src/graph/program.cpp
 +++ b/src/plugins/intel_gpu/src/graph/program.cpp
 @@ -520,6 +520,7 @@ void program::build_program(bool is_internal) {
         prim_info = get_current_stage_info();
         if (get_engine().get_device_info().has_separate_cache)
             transfer_memory_to_device();
 +        check_device_memory_pressure();
     }
 }
 
 @@ -777,6 +778,41 @@ void program::transfer_memory_to_device() {
     }
 }
 
 +bool program::is_device_memory_pressure_risk(uint64_t total_weights_bytes,
 +                                              uint64_t device_max_global_mem_bytes,
 +                                              double margin_ratio) {
 +    if (device_max_global_mem_bytes == 0)
 +        return false;
 +    return static_cast<double>(total_weights_bytes) >= margin_ratio * static_cast<double>(device_max_global_mem_bytes);
 +}
 +
 +void program::check_device_memory_pressure() {
 +    // Integrated GPUs share system RAM directly -- there is no separate, smaller VRAM tier to
 +    // exceed, so this class of oversubscription risk is specific to discrete GPUs.
 +    if (get_engine().get_device_info().dev_type != device_type::discrete_gpu)
 +        return;
 +
 +    uint64_t total_weights_bytes = 0;
 +    for (const auto& node : processing_order) {
 +        if (node->is_type<data>() && !node->is_shape_infer_dep()) {
 +            total_weights_bytes += node->get_output_layout().bytes_count();
 +        }
 +    }
 +
 +    const uint64_t device_max_global_mem_bytes = get_engine().get_device_info().max_global_mem_size;
 +    if (is_device_memory_pressure_risk(total_weights_bytes, device_max_global_mem_bytes)) {
 +        const double weights_gib = total_weights_bytes / (1024.0 * 1024.0 * 1024.0);
 +        const double device_gib = device_max_global_mem_bytes / (1024.0 * 1024.0 * 1024.0);
 +        std::cerr << "[GPU] [WARNING] Model weights (~" << weights_gib << " GiB) are close to or exceed "
 +                  << "device '" << get_engine().get_device_info().dev_name << "' physical memory capacity (~"
 +                  << device_gib << " GiB). This can force the driver into a memory-oversubscription "
 +                  << "fallback that remains functionally correct but may be dramatically slower than "
 +                  << "expected (up to ~75x observed in practice for a similarly-sized model). Consider a "
 +                  << "smaller or more compressed model (e.g. INT4 instead of INT8), or a device with more "
 +                  << "memory. Background: openvinotoolkit/omega#66." << std::endl;
 +    }
 +}
 +
 program::nodes_ordering& program::get_processing_order() { return processing_order; }
 
 const program::nodes_ordering& program::get_processing_order() const { return processing_order; }
 diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp
 new file mode 100644
 index 0000000000..9d09230a70
 --- /dev/null
 +++ b/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp
 @@ -0,0 +1,112 @@
 +// Copyright (C) 2018-2026 Intel Corporation
 +// SPDX-License-Identifier: Apache-2.0
 +//
 +
 +// Unit tests for program::is_device_memory_pressure_risk() / program::check_device_memory_pressure().
 +//
 +// Motivation (openvinotoolkit/omega#66): a hybrid-attention LLM whose INT8 weights (~26 GiB)
 +// slightly exceeded a discrete GPU's physical VRAM (~24.4 GiB) ran ~75x slower than the same
 +// model in INT4 (~15 GiB, comfortably under budget), while remaining functionally correct.
 +// The GPU plugin gave no user-visible diagnostic for this class of failure in release builds:
 +// the only existing check (engine::check_allocatable()) compares against host RAM + VRAM
 +// combined (a coarse OOM-killer guard, irrelevant at this scale) and its Windows-only
 +// "proceeding anyway" log line compiles to a complete no-op without ENABLE_DEBUG_CAPS.
 +//
 +// These tests cover the small, pure decision function in isolation (no device required), plus
 +// a smoke test that invoking the check via a normal program build neither throws nor otherwise
 +// disrupts compilation, regardless of whether the (synthetic, tiny) test topology trips the
 +// warning.
 +
 +#include <cstddef>
 +
 +#include "test_utils.h"
 +#include <intel_gpu/primitives/permute.hpp>
 +#include <intel_gpu/primitives/eltwise.hpp>
 +
 +using namespace cldnn;
 +using namespace tests;
 +
 +class test_device_memory_pressure_warning: public ::testing::Test {};
 +
 +// -------------------------------------------------------------------------------------------
 +// Pure logic tests for program::is_device_memory_pressure_risk() -- no GPU device required.
 +// -------------------------------------------------------------------------------------------
 +
 +TEST_F(test_device_memory_pressure_warning, fits_comfortably_is_not_a_risk) {
 +    // 15 GiB of weights on a 24.4 GiB device (matches the real INT4 Bonsai-27B scenario): not a risk.
 +    const uint64_t weights_15gib = 15ULL * 1024 * 1024 * 1024;
 +    const uint64_t device_24_4gib = 24385683456ULL;  // real GPU.1 VRAM size from clinfo
 +    ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_15gib, device_24_4gib));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, exceeding_capacity_is_a_risk) {
 +    // 26 GiB of weights on a 24.4 GiB device (matches the real INT8 Bonsai-27B scenario): is a risk.
 +    const uint64_t weights_26gib = 26ULL * 1024 * 1024 * 1024;
 +    const uint64_t device_24_4gib = 24385683456ULL;
 +    ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_26gib, device_24_4gib));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, default_margin_flags_near_capacity_before_exceeding) {
 +    // Default margin_ratio is 0.9: weights at 95% of capacity should already be flagged,
 +    // even though they technically still "fit".
 +    const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
 +    const uint64_t weights_95pct = static_cast<uint64_t>(0.95 * device_bytes);
 +    ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_95pct, device_bytes));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, well_under_margin_is_not_flagged) {
 +    const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
 +    const uint64_t weights_50pct = static_cast<uint64_t>(0.50 * device_bytes);
 +    ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_50pct, device_bytes));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, exact_boundary_is_flagged) {
 +    const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
 +    const uint64_t weights_at_margin = static_cast<uint64_t>(0.9 * device_bytes);
 +    ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_at_margin, device_bytes, 0.9));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, custom_margin_ratio_is_respected) {
 +    const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
 +    const uint64_t weights_60pct = static_cast<uint64_t>(0.60 * device_bytes);
 +    // With a stricter 0.5 margin, 60% usage should be flagged...
 +    ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_60pct, device_bytes, 0.5));
 +    // ...but with the default 0.9 margin, it should not be.
 +    ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_60pct, device_bytes));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, zero_device_memory_is_never_a_risk) {
 +    // Defensive: an unknown/zero device capacity must not be (mis)treated as "always exceeded".
 +    ASSERT_FALSE(program::is_device_memory_pressure_risk(1ULL, 0ULL));
 +}
 +
 +TEST_F(test_device_memory_pressure_warning, zero_weights_is_never_a_risk) {
 +    ASSERT_FALSE(program::is_device_memory_pressure_risk(0ULL, 100ULL * 1024 * 1024 * 1024));
 +}
 +
 +// -------------------------------------------------------------------------------------------
 +// Smoke test: building a real (tiny) program must not throw or otherwise misbehave now that
 +// check_device_memory_pressure() runs as part of build_program(). The synthetic topology here
 +// is far too small to ever trip the warning, so this only guards against crashes/exceptions,
 +// not the warning's content (which is logged to stderr and not asserted on here).
 +// -------------------------------------------------------------------------------------------
 +
 +TEST_F(test_device_memory_pressure_warning, program_build_does_not_throw) {
 +    ExecutionConfig cfg = get_test_default_config(get_test_engine());
 +    std::shared_ptr<cldnn::engine> engine1 = create_test_engine();
 +
 +    auto input1 = engine1->allocate_memory({ data_types::f16, format::bfyx, { 2, 2, 32, 32 } });
 +    auto input2 = engine1->allocate_memory({ data_types::f16, format::bfyx, { 2, 2, 32, 32 } });
 +    topology topology(
 +        input_layout("input1", input1->get_layout()),
 +        input_layout("input2", input2->get_layout()),
 +        permute("permute1", input_info("input1"), { 0, 3, 1, 2 }),
 +        permute("permute2", input_info("input2"), { 0, 2, 1, 3 }),
 +        eltwise("eltw", { input_info("permute1"), input_info("permute2") }, eltwise_mode::sum, data_types::f16),
 +        reorder("output", input_info("eltw"), format::bfyx, data_types::f32)
 +    );
 +
 +    std::shared_ptr<cldnn::program> prog;
 +    ASSERT_NO_THROW(prog = program::build_program(*engine1, topology, cfg));
 +    ASSERT_NE(prog, nullptr);
 +}
Precision	Weight file size (ticket data)	Fits in 24.4 GB VRAM?	Observed behavior (ticket)
FP16	51 GB	No (2.1x over)	Hard failure: `CL_OUT_OF_RESOURCES`
INT8	26 GB	No (1.6 GB over)	"Succeeds" but ~75x slower (~3.35 s/token)
INT4 (group-size 128)	15 GB	Yes (~9 GB headroom)	Fast (~44.75 ms/token)
Layers	Weight footprint (INT8)	Weight footprint (INT4)	INT8 result	INT4 result
60	16.04 GB (fits)	8.02 GB (fits)	39.09 ms/inference	19.85 ms/inference (ratio 1.97x — matches isolated-kernel baseline, §4)
88	23.53 GB (fits, ~0.9 GB headroom)	11.77 GB (fits)	57.23 ms/inference (perfectly linear vs the 60-layer point)	not needed (already established linear)
96	25.67 GB (exceeds 24.4 GB by ~1.3 GB)	12.83 GB (fits)	Hard crash: `onednn_verbose,...,error,ocl,errcode -5,CL_OUT_OF_RESOURCES,src/gpu/intel/ocl/kernel.cpp:240`	not applicable (int8-only test)
110	29.41 GB (exceeds by ~5 GB)	14.71 GB (fits, ~9.7 GB headroom)	Hard crash, same `CL_OUT_OF_RESOURCES`	36.30 ms/inference — perfectly linear with the 60-layer point (110/60 × 19.85 = 36.4 ms, measured 36.30 ms)
hidden	intermediate	INT8 median (ms)	INT4 median (ms)	Ratio
1024	3584	0.0935	0.0857	1.09x
2048	7168	0.1017	0.0931	1.09x
4096	14336	0.2234	0.1506	1.48x
5120	17408	0.3131	0.1884	1.66x ← real model's exact dims
8192	28672	0.7510	0.3702	2.03x
12288	32768	1.2450	0.5770	2.16x
16384	43008	2.4612	0.9733	2.53x
File	Change
`src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp`	Declares two new `program` methods: `static bool is_device_memory_pressure_risk(uint64_t total_weights_bytes, uint64_t device_max_global_mem_bytes, double margin_ratio = 0.9)` (pure, side-effect-free, unit-testable without a device) and `void check_device_memory_pressure()` (computes real weight bytes + logs).
`src/plugins/intel_gpu/src/graph/program.cpp`	Implements both methods. `check_device_memory_pressure()` early-returns for integrated GPUs (`dev_type != discrete_gpu` — no separate VRAM tier to exceed), otherwise sums `bytes_count()` over all non-shape-infer `data` (constant) nodes in `processing_order` and compares against `device_info.max_global_mem_size`. Wired into `program::build_program()` immediately after the existing `transfer_memory_to_device()` call (i.e. only for real, non-internal program builds — internal/sub-graph builds are unaffected, matching the existing gating pattern for weight transfer).
`src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp` (new)	9 unit tests: 8 pure-logic tests of `is_device_memory_pressure_risk()` covering fits-comfortably, exceeds-capacity, default/custom margin behavior, and zero-input edge cases (no GPU device needed); 1 integration smoke test that builds a real (tiny) program end-to-end via `program::build_program()` on the actual test device and asserts it does not throw.
Scenario	Weights vs. capacity	Result
Real 0.8B proxy model (`models/qwen3.5-0.8b-int8`, ~1.1 GB)	~4.8% of 22.71 GiB	Compiles and runs correctly in 1.3s. No warning printed — confirms zero false positives for models nowhere near the risk zone.
Synthetic 88-layer stack, INT8 (23.53 GB ≈ 21.92 GiB)	~96.5% of capacity	Warning correctly fires: "Model weights (~21.9239 GiB) are close to or exceed device ... physical memory capacity (~22.7109 GiB)." Inference still completes and runs with stable, linear-scaling latency (57ms/iter) — matching §3.2's original finding that this configuration is "near-limit but still functional." The diagnostic proactively flags real risk before any failure occurs.
Synthetic 96-layer stack, INT8 (25.67 GB ≈ 23.92 GiB)	~105% of capacity (genuinely exceeds)	Warning correctly fires during compilation: "Model weights (~23.917 GiB) are close to or exceed device ... physical memory capacity (~22.7109 GiB)." Immediately afterward, the same underlying `CL_OUT_OF_RESOURCES` (`src/gpu/intel/ocl/kernel.cpp:240`) failure from §3.2 still occurs at `req.infer()` — but now the user sees the actionable, root-caused warning before the cryptic low-level driver exception, rather than only the raw `RuntimeError: ... could not execute a primitive` with no explanation.
Model	Prompt	Generated output
`qwen3.5-0.8b-int8`	"The capital of France is"	"The capital of France is Paris. It is the largest city in France and the seat of"
`qwen3.5-0.8b-int4`	"The capital of France is"	"The capital of France is Paris. It is also the largest city in Europe."
	diff --git a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
	index ac09b4e6c7..732c945f91 100644
	--- a/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
	+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/program.hpp
	@@ -280,6 +280,33 @@ public:
	// returns {-1, -1} if it failed to estimate by allocating given batch size
	std::pair<int64_t/const alloc/, int64_t/general alloc/> get_estimated_device_mem_usage();

	+ // Returns true if `total_weights_bytes` (the total size of constants/weights that need to be
	+ // device-resident) is within `margin_ratio` of, or exceeds, `device_max_global_mem_bytes` (the
	+ // device's physical memory capacity, i.e. device_info::max_global_mem_size -- NOT
	+ // engine::get_max_memory_size(), which also folds in host RAM and is only meant as a last-resort
	+ // guard against being killed by the Linux OOM-killer, not a VRAM-capacity check).
	+ //
	+ // Once a model's resident weights approach or exceed physical device memory, the device/driver is
	+ // forced into a memory-oversubscription regime (host-visible fallback allocations, eviction/paging)
	+ // that remains functionally correct but can be catastrophically slower (up to ~75x observed in
	+ // practice for a hybrid-attention LLM whose INT8 weights slightly exceeded a 24GB GPU's VRAM, while
	+ // the same model's INT4 weights fit comfortably and ran at expected speed) -- see
	+ // openvinotoolkit/omega#66 for the investigation that motivated this diagnostic.
	+ //
	+ // This is a pure, side-effect-free helper (no device/engine access) so it can be exercised directly
	+ // by unit tests without requiring a real GPU device.
	+ static bool is_device_memory_pressure_risk(uint64_t total_weights_bytes,
	+ uint64_t device_max_global_mem_bytes,
	+ double margin_ratio = 0.9);
	+
	+ // Computes the total size of constants/weights in this program and, if it is within margin_ratio of
	+ // or exceeds the device's physical memory capacity, logs a clear, user-visible warning (independent
	+ // of ENABLE_DEBUG_CAPS / OV_VERBOSE, since this class of failure otherwise produces either a hard,
	+ // hard-to-diagnose driver error, or -- on platforms where the driver falls back to a slow oversubscribed
	+ // path -- no diagnostic output at all in a release build). Purely informational: never alters
	+ // allocation, execution, or numerical behavior.
	+ void check_device_memory_pressure();
	+
	using ImplementationsCache = cldnn::LruCacheThreadSafe<kernel_impl_params, std::shared_ptr<primitive_impl>, kernel_impl_params::Hasher>;

	ImplementationsCache& get_implementations_cache() const { return *_impls_cache; }
	diff --git a/src/plugins/intel_gpu/src/graph/program.cpp b/src/plugins/intel_gpu/src/graph/program.cpp
	index 9c7650872a..4feb826f32 100644
	--- a/src/plugins/intel_gpu/src/graph/program.cpp
	+++ b/src/plugins/intel_gpu/src/graph/program.cpp
	@@ -520,6 +520,7 @@ void program::build_program(bool is_internal) {
	prim_info = get_current_stage_info();
	if (get_engine().get_device_info().has_separate_cache)
	transfer_memory_to_device();
	+ check_device_memory_pressure();
	}
	}

	@@ -777,6 +778,41 @@ void program::transfer_memory_to_device() {
	}
	}

	+bool program::is_device_memory_pressure_risk(uint64_t total_weights_bytes,
	+ uint64_t device_max_global_mem_bytes,
	+ double margin_ratio) {
	+ if (device_max_global_mem_bytes == 0)
	+ return false;
	+ return static_cast<double>(total_weights_bytes) >= margin_ratio * static_cast<double>(device_max_global_mem_bytes);
	+}
	+
	+void program::check_device_memory_pressure() {
	+ // Integrated GPUs share system RAM directly -- there is no separate, smaller VRAM tier to
	+ // exceed, so this class of oversubscription risk is specific to discrete GPUs.
	+ if (get_engine().get_device_info().dev_type != device_type::discrete_gpu)
	+ return;
	+
	+ uint64_t total_weights_bytes = 0;
	+ for (const auto& node : processing_order) {
	+ if (node->is_type<data>() && !node->is_shape_infer_dep()) {
	+ total_weights_bytes += node->get_output_layout().bytes_count();
	+ }
	+ }
	+
	+ const uint64_t device_max_global_mem_bytes = get_engine().get_device_info().max_global_mem_size;
	+ if (is_device_memory_pressure_risk(total_weights_bytes, device_max_global_mem_bytes)) {
	+ const double weights_gib = total_weights_bytes / (1024.0 * 1024.0 * 1024.0);
	+ const double device_gib = device_max_global_mem_bytes / (1024.0 * 1024.0 * 1024.0);
	+ std::cerr << "[GPU] [WARNING] Model weights (~" << weights_gib << " GiB) are close to or exceed "
	+ << "device '" << get_engine().get_device_info().dev_name << "' physical memory capacity (~"
	+ << device_gib << " GiB). This can force the driver into a memory-oversubscription "
	+ << "fallback that remains functionally correct but may be dramatically slower than "
	+ << "expected (up to ~75x observed in practice for a similarly-sized model). Consider a "
	+ << "smaller or more compressed model (e.g. INT4 instead of INT8), or a device with more "
	+ << "memory. Background: openvinotoolkit/omega#66." << std::endl;
	+ }
	+}
	+
	program::nodes_ordering& program::get_processing_order() { return processing_order; }

	const program::nodes_ordering& program::get_processing_order() const { return processing_order; }
	diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp
	new file mode 100644
	index 0000000000..9d09230a70
	--- /dev/null
	+++ b/src/plugins/intel_gpu/tests/unit/test_cases/test_device_memory_pressure_warning.cpp
	@@ -0,0 +1,112 @@
	+// Copyright (C) 2018-2026 Intel Corporation
	+// SPDX-License-Identifier: Apache-2.0
	+//
	+
	+// Unit tests for program::is_device_memory_pressure_risk() / program::check_device_memory_pressure().
	+//
	+// Motivation (openvinotoolkit/omega#66): a hybrid-attention LLM whose INT8 weights (~26 GiB)
	+// slightly exceeded a discrete GPU's physical VRAM (~24.4 GiB) ran ~75x slower than the same
	+// model in INT4 (~15 GiB, comfortably under budget), while remaining functionally correct.
	+// The GPU plugin gave no user-visible diagnostic for this class of failure in release builds:
	+// the only existing check (engine::check_allocatable()) compares against host RAM + VRAM
	+// combined (a coarse OOM-killer guard, irrelevant at this scale) and its Windows-only
	+// "proceeding anyway" log line compiles to a complete no-op without ENABLE_DEBUG_CAPS.
	+//
	+// These tests cover the small, pure decision function in isolation (no device required), plus
	+// a smoke test that invoking the check via a normal program build neither throws nor otherwise
	+// disrupts compilation, regardless of whether the (synthetic, tiny) test topology trips the
	+// warning.
	+
	+#include <cstddef>
	+
	+#include "test_utils.h"
	+#include <intel_gpu/primitives/permute.hpp>
	+#include <intel_gpu/primitives/eltwise.hpp>
	+
	+using namespace cldnn;
	+using namespace tests;
	+
	+class test_device_memory_pressure_warning: public ::testing::Test {};
	+
	+// -------------------------------------------------------------------------------------------
	+// Pure logic tests for program::is_device_memory_pressure_risk() -- no GPU device required.
	+// -------------------------------------------------------------------------------------------
	+
	+TEST_F(test_device_memory_pressure_warning, fits_comfortably_is_not_a_risk) {
	+ // 15 GiB of weights on a 24.4 GiB device (matches the real INT4 Bonsai-27B scenario): not a risk.
	+ const uint64_t weights_15gib = 15ULL * 1024 * 1024 * 1024;
	+ const uint64_t device_24_4gib = 24385683456ULL; // real GPU.1 VRAM size from clinfo
	+ ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_15gib, device_24_4gib));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, exceeding_capacity_is_a_risk) {
	+ // 26 GiB of weights on a 24.4 GiB device (matches the real INT8 Bonsai-27B scenario): is a risk.
	+ const uint64_t weights_26gib = 26ULL * 1024 * 1024 * 1024;
	+ const uint64_t device_24_4gib = 24385683456ULL;
	+ ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_26gib, device_24_4gib));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, default_margin_flags_near_capacity_before_exceeding) {
	+ // Default margin_ratio is 0.9: weights at 95% of capacity should already be flagged,
	+ // even though they technically still "fit".
	+ const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
	+ const uint64_t weights_95pct = static_cast<uint64_t>(0.95 * device_bytes);
	+ ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_95pct, device_bytes));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, well_under_margin_is_not_flagged) {
	+ const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
	+ const uint64_t weights_50pct = static_cast<uint64_t>(0.50 * device_bytes);
	+ ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_50pct, device_bytes));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, exact_boundary_is_flagged) {
	+ const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
	+ const uint64_t weights_at_margin = static_cast<uint64_t>(0.9 * device_bytes);
	+ ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_at_margin, device_bytes, 0.9));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, custom_margin_ratio_is_respected) {
	+ const uint64_t device_bytes = 100ULL * 1024 * 1024 * 1024;
	+ const uint64_t weights_60pct = static_cast<uint64_t>(0.60 * device_bytes);
	+ // With a stricter 0.5 margin, 60% usage should be flagged...
	+ ASSERT_TRUE(program::is_device_memory_pressure_risk(weights_60pct, device_bytes, 0.5));
	+ // ...but with the default 0.9 margin, it should not be.
	+ ASSERT_FALSE(program::is_device_memory_pressure_risk(weights_60pct, device_bytes));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, zero_device_memory_is_never_a_risk) {
	+ // Defensive: an unknown/zero device capacity must not be (mis)treated as "always exceeded".
	+ ASSERT_FALSE(program::is_device_memory_pressure_risk(1ULL, 0ULL));
	+}
	+
	+TEST_F(test_device_memory_pressure_warning, zero_weights_is_never_a_risk) {
	+ ASSERT_FALSE(program::is_device_memory_pressure_risk(0ULL, 100ULL * 1024 * 1024 * 1024));
	+}
	+
	+// -------------------------------------------------------------------------------------------
	+// Smoke test: building a real (tiny) program must not throw or otherwise misbehave now that
	+// check_device_memory_pressure() runs as part of build_program(). The synthetic topology here
	+// is far too small to ever trip the warning, so this only guards against crashes/exceptions,
	+// not the warning's content (which is logged to stderr and not asserted on here).
	+// -------------------------------------------------------------------------------------------
	+
	+TEST_F(test_device_memory_pressure_warning, program_build_does_not_throw) {
	+ ExecutionConfig cfg = get_test_default_config(get_test_engine());
	+ std::shared_ptr<cldnn::engine> engine1 = create_test_engine();
	+
	+ auto input1 = engine1->allocate_memory({ data_types::f16, format::bfyx, { 2, 2, 32, 32 } });
	+ auto input2 = engine1->allocate_memory({ data_types::f16, format::bfyx, { 2, 2, 32, 32 } });
	+ topology topology(
	+ input_layout("input1", input1->get_layout()),
	+ input_layout("input2", input2->get_layout()),
	+ permute("permute1", input_info("input1"), { 0, 3, 1, 2 }),
	+ permute("permute2", input_info("input2"), { 0, 2, 1, 3 }),
	+ eltwise("eltw", { input_info("permute1"), input_info("permute2") }, eltwise_mode::sum, data_types::f16),
	+ reorder("output", input_info("eltw"), format::bfyx, data_types::f32)
	+ );
	+
	+ std::shared_ptr<cldnn::program> prog;
	+ ASSERT_NO_THROW(prog = program::build_program(*engine1, topology, cfg));
	+ ASSERT_NE(prog, nullptr);
	+}