Question

我正在尝试增加内存映射文件，我成功地增长了它，但我无法分配我已经请求的所有额外空间 - 我只是得到一个std::bad_alloc而是

以下示例显示了使用g ++在Linux上的效果（我在MSVC上的真实代码中也看到了相同的内容）：

#include <memory>
#include <sstream>

#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/random_generator.hpp>

namespace
{
using MMapManager = boost::interprocess::basic_managed_mapped_file<
    char,
    boost::interprocess::rbtree_best_fit<boost::interprocess::null_mutex_family,
                                         boost::interprocess::offset_ptr<void>,
                                         16u>,
    boost::interprocess::iset_index>;

using MMapAllocatorType = boost::interprocess::allocator<
    std::size_t,
    MMapManager::segment_manager>;

using MMapContainerType = boost::interprocess::vector<
    std::size_t,
    MMapAllocatorType>;

// I've measured this at 256 bytes for my example configuration, but it's not
// documented anywhere, so let's overcompensate
constexpr auto ManagedFileOverhead = 1024u;

boost::filesystem::path getTemporaryFilePath()
{
    auto ss = std::stringstream{};
    ss << "MMap_test_" << boost::uuids::random_generator{}();

    return boost::filesystem::temp_directory_path() / ss.str();
}
}

int main()
{
    // Create memory mapped file, initially for 100 items
    auto capacity = 100u;
    const auto size = (capacity * sizeof(std::size_t)) + ManagedFileOverhead;
    const auto path = getTemporaryFilePath();

    auto file = std::make_unique<MMapManager>(
        boost::interprocess::create_only,
        path.string().c_str(),
        size);
    auto data = file->construct<MMapContainerType>("data_")(file->get_segment_manager());

    // Fill with stuff
    data->reserve(capacity);
    for (auto i = 0u; i < capacity; ++i) {
        data->push_back(i);
    }

    // Let's grow to hold 162 items (100 * golden ratio)
    capacity = 162u;
    const auto newFileSize = (capacity * sizeof(std::size_t)) + ManagedFileOverhead;
    const auto oldFileSize = boost::filesystem::file_size(path);
    const auto extraBytes = newFileSize - oldFileSize;

    // Unmap from the process, and grow
    file.reset();
    MMapManager::grow(path.string().c_str(), extraBytes);

    // Reopen it to re-map it into this process
    file = std::make_unique<MMapManager>(
        boost::interprocess::open_only,
        path.string().c_str());
    data = file->find<MMapContainerType>("data_").first;

    // Allocate it all
    data->reserve(capacity); // Bang, you're dead

    // Close down
    file.reset();
    boost::system::error_code ec;
    boost::filesystem::remove(path, ec);

    return EXIT_SUCCESS;
}

将预留（增长后）设置为155个项目，只需再触发一个std::bad_alloc。

为什么这不起作用？增长是否会在映射文件中产生额外的管理开销，导致我的空间用完时间超出预期？

Answer 1

你只是对分配器做了太多假设。

增长映射文件将在适当的位置发生。增长矢量不会。因此，虽然在增加预留大小后只需要extraBytes ，但在保留期间，您需要足够的空间来容纳旧分配和新分配。< / p>

使用以下方式证明：

MMapManager::grow(path.string().c_str(), oldFileSize + extraBytes);

或者首先清除旧容器：

{ auto file = std::make_unique<MMapManager>(boost::interprocess::open_only, path.string().c_str()); file->destroy<MMapContainerType>("data_"); auto data = file->construct<MMapContainerType>("data_")(file->get_segment_manager()); } MMapManager::grow(path.string().c_str(), extraBytes);

boost :: managed_mapped_file无法分配所有增长的空间

1 个答案: