[NPU] Refactor NPU property handling into owner-specific property managers (#36166)

### Details:
Refactor NPU property handling to remove the shared Properties container
and move ownership into dedicated plugin and compiled model property
managers.

- Introduce owner-specific PluginPropertyManager and
CompiledModelPropertyManager
- Remove the legacy shared properties.hpp/.cpp layer
- Keep shared property registration utilities in
property_registration.hpp
- Update plugin and compiled-model property registration to use the
shared descriptor/registration helpers
- Update NPU functional test object sources to reflect the new file
layout

This makes property ownership explicit, keeps plugin and compiled-model
behavior separate, and reduces special-case logic leaking outside the
owning manager while preserving existing property behavior. The deadlock
fix also restores correct handling of property queries and updates with
extra config.

### Tickets:
 - *CVS-187127*

### AI Assistance:
 - *AI assistance used: yes*
- *Splitting the current version of the property file into the 2
different files: plugin and compiled model property manager*
 - *Update documentation*
 - *Review*

---------

Signed-off-by: Bogdan Pereanu <bogdan.pereanu@intel.com>
Co-authored-by: Bogdan Pereanu <bogdan.pereanu@intel.com>

Author: PatrikStepan

src/plugins/intel_npu/docs/npu-properties-howto.md

@@ -37,6 +37,8 @@ class ZeroDevice : public IDevice {
 
     void updateInfo(const ov::AnyMap& properties) override;
 
+    bool validateCompatibilityDescriptor(const std::string& compatibilityDescriptor) const override;
+
     ZeroDevice& operator=(const ZeroDevice&) = delete;
     ZeroDevice(const ZeroDevice&) = delete;
 

src/plugins/intel_npu/src/backend/include/zero_device.hpp

@@ -196,3 +196,27 @@ void ZeroDevice::updateInfo(const ov::AnyMap& properties) {
         _log.setLevel(properties.at(ov::log::level.name()).as<ov::log::Level>());
     }
 }
+
+bool ZeroDevice::validateCompatibilityDescriptor(const std::string& compatibilityDescriptor) const {
+    if (_initStructs->getZeDrvApiVersion() < ZE_MAKE_VERSION(1, 16)) {
+        OPENVINO_THROW("Compatibility descriptor validation is not supported by this driver");
+    }
+
+    ze_validate_runtime_requirements_output_t output = {};
+    output.stype = ZE_STRUCTURE_TYPE_RUNTIME_REQUIREMENTS_OUTPUT;
+    output.pNext = nullptr;
+
+    const ze_result_t result =
+        zeDeviceValidateRuntimeRequirements(_initStructs->getDevice(), compatibilityDescriptor.c_str(), &output);
+
+    if (result != ZE_RESULT_SUCCESS) {
+        _log.warning("zeDeviceValidateRuntimeRequirements returned error: 0x%x", static_cast<uint32_t>(result));
+        return false;
+    }
+
+    // Only REQUIREMENTS_MET and MET_RECOMPILATION_ADVISABLE are treated as compatible.
+    // NOT_APPLICABLE (the descriptor does not apply to this device) and REQUIREMENTS_NOT_MET are
+    // intentionally treated as incompatible, since neither guarantees the blob runs correctly here
+    return output.result == ZE_VALIDATE_RUNTIME_REQUIREMENTS_RESULT_REQUIREMENTS_MET ||
+           output.result == ZE_VALIDATE_RUNTIME_REQUIREMENTS_RESULT_REQUIREMENTS_MET_RECOMPILATION_ADVISABLE;
+}

src/plugins/intel_npu/src/backend/src/zero_device.cpp

@@ -35,9 +35,8 @@ class ICompilerAdapter {
                                       const FilteredConfig& config) const = 0;
     virtual uint32_t get_version() const = 0;
     virtual std::optional<std::vector<std::string>> get_supported_options() const = 0;
-    virtual bool is_option_supported(std::string optName, std::optional<std::string> optValue = std::nullopt) const = 0;
-
-    virtual bool validate_compatibility_descriptor(const std::string& compatibilityDescriptor) const = 0;
+    virtual bool is_option_supported(const std::string& optName,
+                                     const std::optional<std::string>& optValue = std::nullopt) const = 0;
 
     virtual ~ICompilerAdapter() = default;
 };

src/plugins/intel_npu/src/common/include/intel_npu/common/icompiler_adapter.hpp

@@ -85,6 +85,7 @@ class IDevice : public std::enable_shared_from_this<IDevice> {
                                                              const Config& config) = 0;
 
     virtual void updateInfo(const ov::AnyMap& properties) = 0;
+    virtual bool validateCompatibilityDescriptor(const std::string& compatibilityDescriptor) const = 0;
 
 protected:
     virtual ~IDevice() = default;

src/plugins/intel_npu/src/common/include/intel_npu/common/npu.hpp

@@ -85,21 +85,23 @@ class VCLCompilerImpl final : public std::enable_shared_from_this<VCLCompilerImp
      */
     bool get_supported_options(std::vector<char>& options) const;
 
-    bool is_option_supported(std::string option, std::optional<std::string> optValue = std::nullopt) const;
-
-    std::shared_ptr<void> getLinkedLibrary() const;
+    bool is_option_supported(const std::string& option,
+                             const std::optional<std::string>& optValue = std::nullopt) const;
 
     /**
-     * @brief Validates the compatibility descriptor against the current device information.
-     * This function is used as a fallback check when the driver on the system does not support the required API
-     * @param compatibilityDescriptor The compatibility descriptor (string) to be validated
+     * @brief Checks whether the given option and value are supported by the compiler for the specified device.
+     * This overload is used when a device descriptor is available, allowing device-specific validation.
      * @param in_device_desc Pointer to a device descriptor containing the device ID, number of
-     * tiles and stepping information
-     * @return false if the platform does not meet the requirements specified in the compatibility descriptor,
-     * true if the platform is compatible
+     * tiles and stepping information used for device-specific checks
+     * @param option The option name to check
+     * @param optValue The option value to validate
+     * @return true if the option and value are supported for the given device, false otherwise
      */
-    bool validate_compatibility_descriptor(const std::string& compatibilityDescriptor,
-                                           vcl_device_desc_t* in_device_desc) const;
+    bool is_option_supported(vcl_device_desc_t* in_device_desc,
+                             const std::string& option,
+                             const std::optional<std::string>& optValue = std::nullopt) const;
+
+    std::shared_ptr<void> getLinkedLibrary() const;
 
 private:
     /**

src/plugins/intel_npu/src/compiler_adapter/include/compiler_impl.hpp

@@ -28,12 +28,11 @@ class DriverCompilerAdapter final : public ICompilerAdapter {
 
     std::optional<std::vector<std::string>> get_supported_options() const override;
 
-    bool is_option_supported(std::string optName, std::optional<std::string> optValue = std::nullopt) const override;
+    bool is_option_supported(const std::string& optName,
+                             const std::optional<std::string>& optValue = std::nullopt) const override;
 
     uint32_t get_version() const override;
 
-    bool validate_compatibility_descriptor(const std::string& compatibilityDescriptor) const override;
-
 private:
     bool isCompilerOptionSupported(const FilteredConfig& config,
                                    const ze_graph_compiler_version_info_t& compilerVersion,

src/plugins/intel_npu/src/compiler_adapter/include/driver_compiler_adapter.hpp

@@ -29,12 +29,11 @@ class PluginCompilerAdapter final : public ICompilerAdapter {
 
     std::optional<std::vector<std::string>> get_supported_options() const override;
 
-    bool is_option_supported(std::string optName, std::optional<std::string> optValue = std::nullopt) const override;
+    bool is_option_supported(const std::string& optName,
+                             const std::optional<std::string>& optValue = std::nullopt) const override;
 
     uint32_t get_version() const override;
 
-    bool validate_compatibility_descriptor(const std::string& compatibilityDescriptor) const override;
-
 private:
     std::shared_ptr<ZeroInitStructsHolder> _zeroInitStruct;
 

src/plugins/intel_npu/src/compiler_adapter/include/plugin_compiler_adapter.hpp

@@ -63,8 +63,8 @@ class ZeGraphExtWrappers {
      * @return `true` if the option is supported, `false` if it is not supported,
      *         and `std::nullopt` if the option-support query itself is not supported.
      */
-    std::optional<bool> isOptionSupported(std::string optName,
-                                          std::optional<std::string> optValue = std::nullopt) const;
+    std::optional<bool> isOptionSupported(const std::string& optName,
+                                          const std::optional<std::string>& optValue = std::nullopt) const;
 
     /**
      * @brief Tells us whether or not the driver is able to receive and take into account a hash of the model instead of

src/plugins/intel_npu/src/compiler_adapter/include/ze_graph_ext_wrappers.hpp

@@ -521,13 +521,13 @@ bool VCLCompilerImpl::get_supported_options(std::vector<char>& options) const {
     return false;
 }
 
-bool VCLCompilerImpl::is_option_supported(std::string option, std::optional<std::string> optValue) const {
+bool VCLCompilerImpl::is_option_supported(const std::string& option, const std::optional<std::string>& optValue) const {
     try {
         const char* optname_ch = option.c_str();
         const char* optvalue_ch = optValue.has_value() ? optValue.value().c_str() : nullptr;
         _logger.debug("is_option_supported start for option: %s, value: %s",
                       optname_ch,
-                      optValue ? optvalue_ch : "null");
+                      optvalue_ch ? optvalue_ch : "null");
         THROW_ON_FAIL_FOR_VCL("vclGetCompilerIsOptionSupported",
                               vclGetCompilerIsOptionSupported(_compilerHandle, optname_ch, optvalue_ch),
                               _logHandle);
@@ -540,8 +540,9 @@ bool VCLCompilerImpl::is_option_supported(std::string option, std::optional<std:
     return false;
 }
 
-bool VCLCompilerImpl::validate_compatibility_descriptor(const std::string& compatibilityDescriptor,
-                                                        vcl_device_desc_t* in_device_desc) const {
+bool VCLCompilerImpl::is_option_supported(vcl_device_desc_t* in_device_desc,
+                                          const std::string& option,
+                                          const std::optional<std::string>& optValue) const {
     vcl_compiler_desc_t compilerDesc;
     compilerDesc.version = _vclVersion;
     compilerDesc.debugLevel = static_cast<vcl_log_level_t>(static_cast<int>(Logger::global().level()) + 1);
@@ -555,9 +556,11 @@ bool VCLCompilerImpl::validate_compatibility_descriptor(const std::string& compa
                               vclCompilerCreate(&compilerDesc, in_device_desc, &compilerHandle, &logHandle),
                               nullptr);
 
-        const char* optname_ch = ov::compatibility_check.name();
-        const char* optvalue_ch = compatibilityDescriptor.c_str();
-        _logger.debug("is_option_supported start for option: %s, value: %s", optname_ch, optvalue_ch);
+        const char* optname_ch = option.c_str();
+        const char* optvalue_ch = optValue.has_value() ? optValue.value().c_str() : nullptr;
+        _logger.debug("is_option_supported start for option: %s, value: %s",
+                      optname_ch,
+                      optvalue_ch ? optvalue_ch : "null");
         THROW_ON_FAIL_FOR_VCL("vclGetCompilerIsOptionSupported",
                               vclGetCompilerIsOptionSupported(compilerHandle, optname_ch, optvalue_ch),
                               logHandle);