Add file descriptor support for weightless model loading

Changes:
- Add ov::FdGetterType and ov::hint::fd_getter property
- Extend load_mmap_object() with fd-based overload (Linux only)
- Integrate fd_getter through NPUW deserialization flow
- Windows implementation throws unsupported exception

Signed-off-by: Anoob Anto Kodankandath <[email protected]>

Author: akodanka

src/common/util/include/openvino/util/mmap_object.hpp

@@ -37,6 +37,16 @@ class MappedMemory {
  */
 std::shared_ptr<ov::MappedMemory> load_mmap_object(const std::string& path);
 
+/**
+ * @brief Returns mapped memory for a file from provided file descriptor.
+ * Instead of reading files, we can map the memory via mmap for Linux
+ * in order to avoid time-consuming reading and reduce memory consumption.
+ *
+ * @param fd File descriptor of an already opened file.
+ * @return MappedMemory shared ptr object which keep mmaped memory and control the lifetime.
+ */
+std::shared_ptr<ov::MappedMemory> load_mmap_object(const int fd);
+
 #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
 
 /**

src/common/util/src/os/lin/lin_mmap_object.cpp

@@ -64,26 +64,33 @@ class MapHolder : public MappedMemory {
     MapHolder() = default;
 
     void set(const std::string& path) {
-        int prot = PROT_READ;
         int mode = O_RDONLY;
-        struct stat sb = {};
         m_handle = HandleHolder(open(path.c_str(), mode));
         if (m_handle.get() == -1) {
             throw std::runtime_error("Can not open file " + path +
                                      " for mapping. Ensure that file exists and has appropriate permissions");
         }
-        if (fstat(m_handle.get(), &sb) == -1) {
-            throw std::runtime_error("Can not get file size for " + path);
+        set_from_fd(m_handle.get());
+    }
+
+    void set_from_fd(const int fd) {
+        int prot = PROT_READ;
+        struct stat sb = {};
+        // Use the provided file descriptor directly without taking ownership
+        if (fstat(fd, &sb) == -1) {
+            throw std::runtime_error("Can not get file size for fd=" + std::to_string(fd));
         }
         m_size = sb.st_size;
         if (m_size > 0) {
-            m_data = mmap(nullptr, m_size, prot, MAP_PRIVATE, m_handle.get(), 0);
+            m_data = mmap(nullptr, m_size, prot, MAP_PRIVATE, fd, 0);
             if (m_data == MAP_FAILED) {
-                throw std::runtime_error("Can not create file mapping for " + path + ", err=" + std::strerror(errno));
+                throw std::runtime_error("Can not create file mapping for fd=" + std::to_string(fd) +
+                                         ", err=" + std::strerror(errno));
             }
         } else {
             m_data = MAP_FAILED;
         }
+        // Don't store the handle since we don't own the fd
     }
 
     ~MapHolder() {
@@ -107,4 +114,10 @@ std::shared_ptr<ov::MappedMemory> load_mmap_object(const std::string& path) {
     return holder;
 }
 
+std::shared_ptr<ov::MappedMemory> load_mmap_object(const int fd) {
+    auto holder = std::make_shared<MapHolder>();
+    holder->set_from_fd(fd);
+    return holder;
+}
+
 }  // namespace ov

src/common/util/src/os/win/win_mmap_object.cpp

@@ -134,6 +134,10 @@ std::shared_ptr<ov::MappedMemory> load_mmap_object(const std::string& path) {
     return holder;
 }
 
+std::shared_ptr<ov::MappedMemory> load_mmap_object(const int fd) {
+    OPENVINO_THROW("File descriptor-based memory mapping is not supported on Windows. Use path-based load_mmap_object instead.");
+}
+
 #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
 
 std::shared_ptr<ov::MappedMemory> load_mmap_object(const std::wstring& path) {

src/inference/include/openvino/runtime/properties.hpp

@@ -241,6 +241,14 @@ static constexpr Property<std::string, PropertyMutability::RO> model_name{"NETWO
 static constexpr Property<uint32_t, PropertyMutability::RO> optimal_number_of_infer_requests{
     "OPTIMAL_NUMBER_OF_INFER_REQUESTS"};
 
+/**
+ * @brief Type definition for file descriptor getter callback.
+ * Function that takes a file path string and returns a file descriptor as int.
+ * This is useful for scenarios where file access needs to be controlled externally.
+ * @ingroup ov_runtime_cpp_prop_api
+ */
+using FdGetterType = std::function<int(const std::string&)>;
+
 /**
  * @brief Namespace with hint properties
  */
@@ -532,6 +540,14 @@ static constexpr Property<uint32_t> num_requests{"PERFORMANCE_HINT_NUM_REQUESTS"
  */
 static constexpr Property<std::shared_ptr<const ov::Model>> model{"MODEL_PTR"};
 
+/**
+ * @brief This key identifies callback function to get file descriptor for a given file path.
+ * The callback takes a file path string and returns a file descriptor as int.
+ * This is useful for scenarios where file access needs to be controlled externally.
+ * @ingroup ov_runtime_cpp_prop_api
+ */
+static constexpr Property<FdGetterType> fd_getter{"FD_GETTER"};
+
 /**
  * @brief Special key for auto batching feature configuration. Enabled by default
  * @ingroup ov_runtime_cpp_prop_api

src/plugins/intel_npu/src/plugin/npuw/compiled_model.cpp

@@ -1141,11 +1141,19 @@ std::shared_ptr<ov::npuw::CompiledModel> ov::npuw::CompiledModel::deserialize(
         std::shared_ptr<ov::Model> model_ptr;
         // Cache model's constants
         WeightsContext::ConstsCache consts_cache;
+        ov::FdGetterType fd_getter = nullptr;
         if (is_weightless) {
             if (properties.find(ov::weights_path.name()) != properties.end()) {
                 weights_path = properties.at(ov::weights_path.name()).as<std::string>();
                 NPUW_ASSERT(!weights_path.empty() &&
                             "Empty weights_path. Please provide WEIGHTS_PATH or MODEL_PTR in the configuration.");
+
+                // Check if fd_getter function is provided
+                if (const auto fd_it = properties.find(ov::hint::fd_getter.name()); fd_it != properties.end()) {
+                    if (fd_it->second.is<ov::FdGetterType>()) {
+                        fd_getter = fd_it->second.as<ov::FdGetterType>();
+                    }
+                }
             } else if (properties.find(ov::hint::model.name()) != properties.end()) {
                 model_ptr = std::const_pointer_cast<ov::Model>(
                                 properties.at(ov::hint::model.name()).as<std::shared_ptr<const ov::Model>>())
@@ -1181,7 +1189,14 @@ std::shared_ptr<ov::npuw::CompiledModel> ov::npuw::CompiledModel::deserialize(
         ov::npuw::s11n::WeightsPtr weights = nullptr;
         if (is_weightless) {
             if (!weights_path.empty()) {
-                auto mapped_memory = ov::load_mmap_object(weights_path);
+                std::shared_ptr<ov::MappedMemory> mapped_memory;
+                // Use fd_getter if available, otherwise use default mmap
+                if (fd_getter) {
+                    int fd = fd_getter(weights_path);
+                    mapped_memory = ov::load_mmap_object(fd);
+                } else {
+                    mapped_memory = ov::load_mmap_object(weights_path);
+                }
                 weights = std::make_shared<ov::npuw::s11n::Weights>(mapped_memory->data(),
                                                                     mapped_memory->size(),
                                                                     mapped_memory);
@@ -1191,7 +1206,8 @@ std::shared_ptr<ov::npuw::CompiledModel> ov::npuw::CompiledModel::deserialize(
         // FIXME: prolong lifetime of ov::Model for import with MODEL_PTR.
         // Unclear why it's needed, but without saving consts_cache until bank evaluation,
         // the memory is freed somewhere.
-        compiled->m_import_weights_ctx = WeightsContext(weights, weights_path, consts_cache, compiled->m_bf16_consts);
+        compiled->m_import_weights_ctx =
+            WeightsContext(weights, weights_path, consts_cache, compiled->m_bf16_consts, fd_getter);
 
         // Deserialize compiled submodels
         std::size_t subm_size = 0;

src/plugins/intel_npu/src/plugin/npuw/lazy_tensor.cpp

@@ -64,7 +64,14 @@ ov::Tensor Const::eval() const {
     if (!m_weights_path.empty()) {
         NPUW_ASSERT(!m_read_from_bin &&
                     "Trying to read weight from weights file, but the weight has been already deserialized!");
-        auto mapped_memory = ov::load_mmap_object(m_weights_path);
+        std::shared_ptr<ov::MappedMemory> mapped_memory;
+        // Use fd_getter if available, otherwise use default mmap
+        if (m_fd_getter) {
+            int fd = m_fd_getter(m_weights_path);
+            mapped_memory = ov::load_mmap_object(fd);
+        } else {
+            mapped_memory = ov::load_mmap_object(m_weights_path);
+        }
         m_mmaped_weights =
             std::make_shared<ov::npuw::s11n::Weights>(mapped_memory->data(), mapped_memory->size(), mapped_memory);
         return ov::Tensor(m_cached_type, m_cached_shape, m_mmaped_weights->get_ptr(m_offset));
@@ -118,6 +125,8 @@ void Const::read_weight(const ov::npuw::s11n::WeightsContext& ctx) {
             NPUW_ASSERT(!ctx.weights_path.empty());
             // Just save weights_path for the eval() to call the actual mmap.
             m_weights_path = ctx.weights_path;
+            // Also save fd_getter if available
+            m_fd_getter = ctx.fd_getter;
         }
     } else {
         auto it = ctx.consts_cache.find({m_offset, m_byte_size});

src/plugins/intel_npu/src/plugin/npuw/lazy_tensor.hpp

@@ -108,6 +108,7 @@ class Const {
     std::size_t m_byte_size = 0;
     ov::Tensor m_read_from_bin;
     std::string m_weights_path;
+    ov::FdGetterType m_fd_getter = nullptr;
     mutable ov::npuw::s11n::WeightsPtr m_mmaped_weights = nullptr;
     // FIXME: special case when a new Constant was added into the model,
     // then made into LazyTensor during folding. We need to keep a copy of it,

src/plugins/intel_npu/src/plugin/npuw/serialization.cpp

@@ -28,11 +28,13 @@ ov::npuw::s11n::WeightsContext::WeightsContext(bool _is_weightless,
 ov::npuw::s11n::WeightsContext::WeightsContext(const ov::npuw::s11n::WeightsPtr& _weights,
                                                const std::string& _weights_path,
                                                const s11n::WeightsContext::ConstsCache& _consts_cache,
-                                               const BF16Cache& _bf16_consts)
+                                               const BF16Cache& _bf16_consts,
+                                               const ov::FdGetterType& _fd_getter)
     : weights(_weights),
       weights_path(_weights_path),
       consts_cache(_consts_cache),
-      bf16_consts(_bf16_consts) {
+      bf16_consts(_bf16_consts),
+      fd_getter(_fd_getter) {
     is_weightless = _weights || !_consts_cache.empty();
 }
 

src/plugins/intel_npu/src/plugin/npuw/serialization.hpp

@@ -17,6 +17,8 @@
 #include <unordered_set>
 #include <vector>
 
+#include "openvino/runtime/properties.hpp"
+
 namespace ov {
 namespace npuw {
 namespace s11n {
@@ -126,7 +128,8 @@ struct WeightsContext {
     WeightsContext(const ov::npuw::s11n::WeightsPtr& _weights,
                    const std::string& _weights_path,
                    const ConstsCache& _consts_cache,
-                   const BF16Cache& _bf16_consts);
+                   const BF16Cache& _bf16_consts,
+                   const ov::FdGetterType& _fd_getter = nullptr);
 
     WeightsContext& operator=(const WeightsContext& other) = default;
 
@@ -141,6 +144,7 @@ struct WeightsContext {
     std::string weights_path;
     ConstsCache consts_cache;
     BF16Cache bf16_consts;
+    ov::FdGetterType fd_getter = nullptr;
 };
 
 BF16Cache get_bf16_consts(const std::shared_ptr<ov::Model>& model);