Boost进程间共享内存麻烦

Question

我正在使用 Boost 的进程间访问共享内存。
我试图做的是将映射存储在共享内存中，并从跨进程访问。下面是我尝试执行相同操作的代码部分 --

SharedMemoryManager.h

#ifndef SHARED_MEMORY_MANAGER_H
#define SHARED_MEMORY_MANAGER_H

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/sync/named_semaphore.hpp>
#include <boost/interprocess/containers/map.hpp>

enum RangeBound { START, END, SINGLE };

typedef struct {
    std::string code;
    RangeBound flag;
} ZipRangeInfo;

typedef std::string RangeKeyType;
typedef std::pair<const RangeKeyType, ZipRangeInfo> RangeValueType;

typedef boost::interprocess::allocator<RangeValueType, boost::interprocess::managed_shared_memory::segment_manager> RangeBasedShmemAllocator;

typedef boost::interprocess::map<RangeKeyType, ZipRangeInfo, std::less<RangeKeyType>, RangeBasedShmemAllocator> SharedRangeBasedMap;

class SharedMemoryManager {

private:
    static boost::interprocess::managed_shared_memory *segment;
    static RangeBasedShmemAllocator *alloc_range_map;
public:
    static char* get_range_based_routing_code(char *dataItem, char *fileName);
    static SharedRangeBasedMap* get_range_based_routing_table(char *fileName );
    static void load_range_based_routing_table( const char *fileName );
};

#endif //SHARED_MEMORY_MANAGER_H

和 SharedmemoryManager.cpp

#include "SharedMemoryManager.h"

const std::string shm_code_util("SharedMemoryUtil");

//Initializing shared memory of size 1 GB.
boost::interprocess::managed_shared_memory *SharedMemoryManager::segment =
        new boost::interprocess::managed_shared_memory(
                boost::interprocess::open_or_create, "CRS", 1024 * 1024 * 1024);
RangeBasedShmemAllocator *SharedMemoryManager::alloc_range_map =
        new RangeBasedShmemAllocator(segment->get_segment_manager());

// Method definitions

char* SharedMemoryManager::get_range_based_routing_code(char *dataItem,
        char *fileName) {

    char* result = NULL;
    // Postal Code Scrubbing Logic
    if (dataItem == NULL)
        return NULL;
    try {
        char *dataIt = (char *) calloc(strlen(dataItem) + 1, sizeof(char));
        strcpy(dataIt, dataItem);

        SharedRangeBasedMap *routing_table = get_range_based_routing_table(
                fileName);
        std::cout << "Hash Table Size :" << routing_table->size();
        if (routing_table != NULL && routing_table->size() > 0) {
            RangeKeyType key(dataItem);
            SharedRangeBasedMap::const_iterator routing_entry =
                    routing_table->lower_bound(key);
            std::cout << "Got iterator";
            if (routing_entry == routing_table->end()) {
                return NULL;
            }
            if (routing_entry->first == key
                    || routing_entry->second.flag == END) {
                result = (char *) routing_entry->second.code.c_str();
            }
        }
        free(dataIt);

        return result;
    } catch (std::exception &e) {
        throw;
    }
}

SharedRangeBasedMap* SharedMemoryManager::get_range_based_routing_table(
        char *fileName) {

    boost::interprocess::named_semaphore sync_semaphore(
            boost::interprocess::open_or_create, "LoadFilesSemaphore", 1);
    sync_semaphore.wait();
    try {
        SharedRangeBasedMap *routing_table = segment->find_or_construct<
                SharedRangeBasedMap>(fileName)(std::less<RangeKeyType>(),
                        *alloc_range_map);
        if (routing_table->size() == 0) {
            load_range_based_routing_table(fileName);
        }
        sync_semaphore.post();

        return routing_table;
    } catch (...) {
        std::cout << "An exception was thrown; couldn't load post codes.";
        sync_semaphore.post();
        return NULL;
    }
    return NULL;
}

void SharedMemoryManager::load_range_based_routing_table(const char *fileName) {

    SharedRangeBasedMap *range_based_map = NULL;
    range_based_map = segment->find_or_construct<SharedRangeBasedMap>(
                fileName)(std::less<RangeKeyType>(), *alloc_range_map);


    // Build the hash if empty
    if (range_based_map != NULL && range_based_map->size() == 0) {
        //logic to populate the map - tested to work correctly
    }
}

我面临的问题是调用get_range_based_routing_code 的第一个进程，从而初始化共享内存并填充映射，能够从映射中检索值，而任何后续调用@987654324 @ 遇到分段错误。
通过添加cout 语句，我已经能够推断出以下行是导致错误的行（或者是 lsat 执行行）--

SharedRangeBasedMap::const_iterator routing_entry =
                    routing_table->lower_bound(key);

我无法弄清楚这一点，而且我对 C++ 的缺乏经验也无济于事。有什么指点吗？

Answer 1

您也必须从共享内存区域分配 keytype。

有许多 Boost IPC 示例为此目的定义了 shared_string。您可以重复使用它。

---

ZipRangeInfo 类型中的 std::string 也是如此。是的，这是很多工作和麻烦。在实践中，您可能希望将ZipRangeInfo::code 替换为一些静态大小的boost::array<char, ...> 或char[N]