如何防止将在 windows 临时删除关闭文件上打开的内存映射刷新到磁盘

Question

更新 2 / TL;DR

Is there some way to prevent dirty pages of a windows FILE_FLAG_DELETE_ON_CLOSE temporary file from being flushed as a result of closing memory maps opened on these files?

是的。如果您在初始创建后不需要对文件本身做任何事情并且您实施了一些命名约定，这可以通过 [= 中解释的策略实现23=].

注意：我仍然很想找出为什么根据地图的创建方式和顺序 [=75] 行为会有如此大差异的原因=].

我一直在研究进程间共享内存数据结构的一些策略，该数据结构允许通过使用“内存块”链来增加和缩减其在 windows 上的承诺容量。

一种可能的方法是使用页面文件支持的命名内存映射作为块内存。这种策略的一个优点是可以使用 SEC_RESERVE 保留一大块内存地址 space 并使用 VirtualAlloc 和 MEM_COMMIT 增量分配它。缺点似乎是 (a) 要求具有 SeCreateGlobalPrivilege 权限以允许在 Global\ 名称 space 中使用可共享名称和 (b) 所有提交的内存都对系统有贡献承担责任。

为了避免这些缺点，我开始研究临时文件支持的内存映射 的使用。 IE。内存映射到使用 FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY 标志组合创建的文件。这似乎是一个推荐的策略，根据例如。 this blog post 应防止将映射内存刷新到磁盘（除非内存压力导致脏映射页面被分页）。

然而，我观察到在所属进程退出之前关闭 map/file 句柄会导致脏页刷新到磁盘。即使 view/file 句柄不是创建脏页的句柄，并且当这些 views/file 句柄在页面 'dirtied' 在不同视图中打开后打开时，也会发生这种情况。

似乎改变处理顺序（即先取消映射视图或先关闭文件句柄）对何时启动磁盘刷新有一些影响，但对刷新发生的事实没有影响。

所以我的问题是：

Is there some way to use temporary file backed memory maps and prevent them from flushing dirty pages when the map/file is closed, taking into account that multiple threads within a process/multiple processes may have open handles/views to such a file?

If not, what is/could be the reason for the observed behavior?

Is there an alternative strategy that I may have overlooked?

更新
一些附加信息：当运行以下示例代码的“arena1”和“arena2”部分位于两个单独（独立）进程中时，“arena1”是创建共享内存区域的进程，“arena2”是一个打开它们，观察到 maps/chunks 有脏页的以下行为：

如果在“arena1”进程中的文件句柄之前关闭视图，它会将这些块中的每一个刷新到磁盘，这似乎是一个（部分）同步进程（即它会阻塞处理线程几秒钟），与“arena2”进程是否启动无关。
如果在查看之前关闭文件句柄，则磁盘刷新只会发生在那些 maps/chunks 在“arena1”进程中关闭的块上，而“arena2”进程仍然有这些块的打开句柄，并且它们似乎是 'asynchronous'，即不阻塞应用程序线程。

请参阅下面的 (c++) 示例代码，它可以在我的系统（x64、Win7）上重现该问题：

static uint64_t start_ts;
static uint64_t elapsed() {
    return ::GetTickCount64() - start_ts;
}

class PageArena {
public:
    typedef uint8_t* pointer;

    PageArena(int id, const char* base_name, size_t page_sz, size_t chunk_sz, size_t n_chunks, bool dispose_handle_first) :
        id_(id), base_name_(base_name), pg_sz_(page_sz), dispose_handle_first_(dispose_handle_first) {
        for (size_t i = 0; i < n_chunks; i++)
            chunks_.push_back(new Chunk(i, base_name_, chunk_sz, dispose_handle_first_));
    }
    ~PageArena() {
        for (auto i = 0; i < chunks_.size(); ++i) {
            if (chunks_[i])
                release_chunk(i);
        }
        std::cout << "[" << ::elapsed() << "] arena " << id_ << " destructed" << std::endl;
    }

    pointer alloc() {
        auto ptr = chunks_.back()->alloc(pg_sz_);
        if (!ptr) {
            chunks_.push_back(new Chunk(chunks_.size(), base_name_, chunks_.back()->capacity(), dispose_handle_first_));
            ptr = chunks_.back()->alloc(pg_sz_);
        }
        return ptr;
    }
    size_t num_chunks() {
        return chunks_.size();
    }
    void release_chunk(size_t ndx) {
        delete chunks_[ndx];
        chunks_[ndx] = nullptr;
        std::cout << "[" << ::elapsed() << "] chunk " << ndx << " released from arena " << id_ << std::endl;
    }

private:
    struct Chunk {
    public:
        Chunk(size_t ndx, const std::string& base_name, size_t size, bool dispose_handle_first) :
            map_ptr_(nullptr), tail_(nullptr),
            handle_(INVALID_HANDLE_VALUE), size_(0),
            dispose_handle_first_(dispose_handle_first) {

            name_ = name_for(base_name, ndx);
            if ((handle_ = create_temp_file(name_, size)) == INVALID_HANDLE_VALUE)
                handle_ = open_temp_file(name_, size);
            if (handle_ != INVALID_HANDLE_VALUE) {
                size_ = size;
                auto map_handle = ::CreateFileMappingA(handle_, nullptr, PAGE_READWRITE, 0, 0, nullptr);
                tail_ = map_ptr_ = (pointer)::MapViewOfFile(map_handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
                ::CloseHandle(map_handle); // no longer needed.
            }
        }
        ~Chunk() {
            if (dispose_handle_first_) {
                close_file();
                unmap_view();
            } else {
                unmap_view();
                close_file();
            }
        }
        size_t capacity() const {
            return size_;
        }
        pointer alloc(size_t sz) {
            pointer result = nullptr;
            if (tail_ + sz <= map_ptr_ + size_) {
                result = tail_;
                tail_ += sz;
            }
            return result;
        }

    private:
        static const DWORD kReadWrite = GENERIC_READ | GENERIC_WRITE;
        static const DWORD kFileSharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
        static const DWORD kTempFlags = FILE_ATTRIBUTE_NOT_CONTENT_INDEXED | FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;

        static std::string name_for(const std::string& base_file_path, size_t ndx) {
            std::stringstream ss;
            ss << base_file_path << "." << ndx << ".chunk";
            return ss.str();
        }
        static HANDLE create_temp_file(const std::string& name, size_t& size) {
            auto h = CreateFileA(name.c_str(), kReadWrite, kFileSharing, nullptr, CREATE_NEW, kTempFlags, 0);
            if (h != INVALID_HANDLE_VALUE) {
                LARGE_INTEGER newpos;
                newpos.QuadPart = size;
                ::SetFilePointerEx(h, newpos, 0, FILE_BEGIN);
                ::SetEndOfFile(h);
            }
            return h;
        }
        static HANDLE open_temp_file(const std::string& name, size_t& size) {
            auto h = CreateFileA(name.c_str(), kReadWrite, kFileSharing, nullptr, OPEN_EXISTING, kTempFlags, 0);
            if (h != INVALID_HANDLE_VALUE) {
                LARGE_INTEGER sz;
                ::GetFileSizeEx(h, &sz);
                size = sz.QuadPart;
            }
            return h;
        }
        void close_file() {
            if (handle_ != INVALID_HANDLE_VALUE) {
                std::cout << "[" << ::elapsed() << "] " << name_ << " file handle closing" << std::endl;
                ::CloseHandle(handle_);
                std::cout << "[" << ::elapsed() << "] " << name_ << " file handle closed" << std::endl;
            }
        }
        void unmap_view() {
            if (map_ptr_) {
                std::cout << "[" << ::elapsed() << "] " << name_ << " view closing" << std::endl;
                ::UnmapViewOfFile(map_ptr_);
                std::cout << "[" << ::elapsed() << "] " << name_ << " view closed" << std::endl;
            }
        }

        HANDLE          handle_;
        std::string     name_;
        pointer         map_ptr_;
        size_t          size_;
        pointer         tail_;
        bool            dispose_handle_first_;
    };

    int id_;
    size_t pg_sz_;
    std::string base_name_;
    std::vector<Chunk*> chunks_;
    bool dispose_handle_first_;
};

static void TempFileMapping(bool dispose_handle_first) {
    const size_t chunk_size = 256 * 1024 * 1024;
    const size_t pg_size = 8192;
    const size_t n_pages = 100 * 1000;
    const char*  base_path = "data/page_pool";
    start_ts = ::GetTickCount64();

    if (dispose_handle_first)
        std::cout << "Mapping with 2 arenas and closing file handles before unmapping views." << std::endl;
    else
        std::cout << "Mapping with 2 arenas and unmapping views before closing file handles." << std::endl;
    {
        std::cout << "[" << ::elapsed() << "] " << "allocating " << n_pages << " pages through arena 1." << std::endl;
        PageArena arena1(1, base_path, pg_size, chunk_size, 1, dispose_handle_first);
        for (size_t i = 0; i < n_pages; i++) {
            auto ptr = arena1.alloc();
            memset(ptr, (i + 1) % 256, pg_size); // ensure pages are dirty.
        }
        std::cout << "[" << elapsed() << "] " << arena1.num_chunks() << " chunks created." << std::endl;
        {
            PageArena arena2(2, base_path, pg_size, chunk_size, arena1.num_chunks(), dispose_handle_first);
            std::cout << "[" << ::elapsed() << "] arena 2 loaded, going to release chunks 1 and 2 from arena 1" << std::endl;
            arena1.release_chunk(1);
            arena1.release_chunk(2);
        }
    }
}

请分别参考此gist that contains the output of running the above code and links to screen captures of system free memory and disk activity when running TempFileMapping(false) and TempFileMapping(true)

Answer 1

在赏金期结束后，没有任何答案可以提供更多见解或解决上述问题，我决定更深入地挖掘，并通过几种操作组合和顺序进行更多试验。

因此，我相信我已经找到了一种方法来实现进程之间通过临时的、关闭时删除的文件共享内存映射，这些文件在关闭时不会刷新到磁盘。

基本思想涉及在新创建临时文件时创建内存映射，其映射名称可用于调用OpenFileMapping:

// build a unique map name from the file name.
auto map_name = make_map_name(file_name); 

// Open or create the mapped file.
auto mh = ::OpenFileMappingA(FILE_MAP_ALL_ACCESS, false, map_name.c_str());
if (mh == 0 || mh == INVALID_HANDLE_VALUE) {
    // existing map could not be opened, create the file.
    auto fh = ::CreateFileA(name.c_str(), kReadWrite, kFileSharing, nullptr, CREATE_NEW, kTempFlags, 0);
    if (fh != INVALID_HANDLE_VALUE) {
        // set its size.
        LARGE_INTEGER newpos;
        newpos.QuadPart = desired_size;
        ::SetFilePointerEx(fh, newpos, 0, FILE_BEGIN);
        ::SetEndOfFile(fh);
        // create the map
        mh = ::CreateFileMappingA(mh, nullptr, PAGE_READWRITE, 0, 0, map_name.c_str());
        // close the file handle
        // from now on there will be no accesses using file handles.
        ::CloseHandle(fh);
    }
}

因此，文件句柄仅在新创建文件时使用，并在创建地图后立即关闭，而地图句柄本身保持打开状态，以允许打开映射而不需要访问文件句柄。请注意，这里存在竞争条件，我们需要在任何 "real code" 中处理（以及添加适当的错误检查和处理）。

所以如果我们得到一个有效的地图句柄，我们可以创建视图:

auto map_ptr = MapViewOfFile(mh, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (map_ptr) {
    // determine its size.
    MEMORY_BASIC_INFORMATION mbi;
    if (::VirtualQuery(map_ptr, &mbi, sizeof(MEMORY_BASIC_INFORMATION)) > 0) 
        map_size = mbi.RegionSize;
}

一段时间后关闭映射文件：在取消映射视图之前关闭映射句柄：

if (mh == 0 || mh == INVALID_HANDLE_VALUE) {
    ::CloseHandle(mh);
    mh = INVALID_HANDLE_VALUE;
}
if (map_ptr) {
    ::UnmapViewOfFile(map_ptr);
    map_ptr = 0;
    map_size = 0;
}

而且，根据我目前执行的测试，这不会导致关闭时将脏页刷新到磁盘，问题已解决。无论如何，可能仍然存在跨会话地图名称共享问题。

Answer 2

如果我理解正确，注释掉 Arena2 部分代码将重现该问题，而无需第二个过程。我试过这个：

为了方便，我编辑了base_path如下：

char base_path[MAX_PATH];
GetTempPathA(MAX_PATH, base_path);
strcat_s(base_path, MAX_PATH, "page_pool");

我编辑 n_pages = 1536 * 128 使已用内存达到 1.5GB，而你的内存约为 800mb。
我测试了 TempFileMapping(false) 和 TempFileMapping(true)，一次一个，结果相同。
我用 Arena2 进行了测试，结果相同。Arena2
我在 Win8.1 x64 和 Win7 x64 上进行了测试，结果相同 ±10%。
在我的测试中，代码运行时间为 2400 毫秒 ±10%，只有 500 毫秒 ±10% 用于释放。这显然不足以在我那里的低转速静音 HDD 上刷新 1.5GB。

所以，问题是，你在观察什么？我建议你：

提供您的时间进行比较
换台电脑测试，注意排除"same antivirus"
确认您没有遇到 RAM 不足的问题。
使用 xperf 查看冻结期间发生的情况。

更新我已经在另一个 Win7 x64 上进行了测试，时间为 890 毫秒，430 毫秒用于 dealloc。我查看了您的结果，非常值得怀疑的是每次在您的计算机上冻结几乎正好 4000 毫秒。我相信这绝非巧合。此外，现在问题很明显与您正在使用的特定机器有关。所以我的建议是：

如上所述，自己在另一台电脑上测试
如上所述，使用XPerf，它可以让你看到冻结期间用户模式和内核模式到底发生了什么（我真的怀疑中间有一些非标准驱动程序）
播放页数，看看它如何影响冻结长度。
尝试将文件存储在您最初测试过的同一台计算机上的不同磁盘驱动器上。

如何防止将在 windows 临时删除关闭文件上打开的内存映射刷新到磁盘

How to prevent flushing to disk of a memory map opened on a windows temporary delete-on-close file

language-agnostic

windows

winapi

temporary-files

memory-mapped-files