标签: shared-memory

我正在寻找一个程序来查看和浏览Windows x32/x64中的(本地)共享内存.

我知道这是存在的,因为我之前已经看过它了.出于某种原因谷歌和MSDN在这个问题上让我失望.

我即将在C#中开发Windows服务.此服务需要跟踪系统中的事件,并不时将一些数据写入文件.这些正在进行的事件形成一定的状态,因此我会将状态保留在内存中并在事件到达时更新它.我不想让事情过于复杂,所以我不希望状态在磁盘上持久化,但我想知道我是否能以某种方式使其在内存中持久化,以便在服务崩溃时(并且自动重启Windows)它可以从它离开的地方继续前进(可能会丢失一些事件,而不是什么大不了的事).

我正在考虑创建一个"共享"内存区域,从而让Windows管理它,并仅在服务中使用它 - 但我不确定该服务在服务终止后是否会持续存在.

有任何想法吗？

编辑:我不是在寻找一个矫枉过正的解决方案.数据有点重要,所以我想让它在内存中等待,直到服务重新启动,但数据不是太重要.如果我可以轻松地持久保存数据,而不使用文件,外部第三方进程等等,那么这将是一个很好的功能.我理想的解决方案是一个简单的内置功能(在.NET或Windows中),它将为我提供一些内存持久性,只是为了从崩溃事件中恢复.

我有一个非常复杂的类(它内部有unordered_map等等),我想用两个我的进程共享它的一个对象.我可以简单地将指针从一个进程传递到另一个进程吗？我想,不,但希望听到"是的!".

如果"不",我将很高兴看到任何链接如何处理这种情况.我需要为所有进程只有一个这个对象的实例,因为它非常大,并且所有进程都可以用于只读.

• shm_open()
• mmap() 预定义的大 length
• fork() (几次)
• ftruncate() 随意

这样做的目的是确保生成的每个进程fork()在同一地址都有一个共享段.然而,我不想让RAM一直保持忙碌,而是动态调整它的大小(大小为0 - 大length).

这可以吗？有UB吗？

我最近一直在努力开发基于内存池的自定义分配器,它在分配器的多个实例之间共享.

目的是分配器与STL和基于标准C++的容器兼容,例如vector,deque,map,string等

然而,特别是某些事情让我有些困惑.容器的各种实现(例如std :: vector,std :: string)使用小缓冲区优化 - 基于堆栈的分配用于小的初始内存需求.

例如,MSVC9.1在basic_string类中具有以下成员:

union _Bxty
{   // storage for small buffer or pointer to larger one
   _Elem _Buf[_BUF_SIZE];
   _Elem *_Ptr;
   char _Alias[_BUF_SIZE];  // to permit aliasing
} _Bx;

我无法看到在实例化这样的容器时,如何只能实现并始终使用提供的分配器而不使用SBO.我问,因为实现自定义分配器的意图之一是能够在共享内存上下文中使用它们,其中共享内存的数量可能小于各种实现可能使用的SBO限制.

例如,我想有一种情况,我可以有两个std :: string实例,每个进程共享一个公共内存块,可能小于或等于SBO上限.

可能相关:5月std :: vector使用小缓冲区优化？

typedef std::vector<int,mysharedmemallocator> shmvtype;

shmvtype v(2,0); //<-- if SBO then error as memory is allocated on
                 //stack not via the allocator

v[1] = 1234;  //<-- if SBO then error as wrong piece of memory …

假设我想对可能非常大的文件执行顺序写入.

如果我在整个区域上mmap()一个巨大的区域和madvise(MAD​​V_SEQUENTIAL),那么我可以以相对有效的方式写入内存.我已经开始工作了.

现在,为了在我编写时释放各种OS资源,我偶尔会在已经写入的小块内存上执行munmap().我担心的是munmap()和msync()会阻塞我的线程,等待数据物理地提交到磁盘.我根本无法放慢作家的速度,所以我需要找到另一种方式.

在已经写好的小块内存中使用madvise(MAD​​V_DONTNEED)会更好吗？我想告诉操作系统懒惰地将内存写入磁盘,而不是阻止我的调用线程.

madvise()的联机帮助页有这样说,这是相当模糊的:

MADV_DONTNEED
Do  not expect access in the near future.  (For the time being, the 
application is finished with the given range, so the kernel can free
resources associated with it.)  Subsequent accesses of pages in this
range will succeed, but will result either in re-loading  of the memory
contents from the underlying mapped file (see mmap(2)) or
zero-fill-on-demand pages for mappings without an underlying file.

我尝试编写一个小应用程序来熟悉用户空间中的写时复制概念.我已经阅读了MSalters的回答,并认为只有当我开始使用mmap'ed文件存储我的数据时它才会起作用.因为我不需要基于文件的持久性,我试图用共享内存做同样的事情.首先我mmap编写并初始化了一个shm fd,然后我MAP_PRIVATE再次映射了第二个副本并从中读取.但是,只需读取它就会导致内核复制整个内容,花费更多时间并占用内存的两倍.为什么不做COW？

这是我提出的用于说明行为的程序:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <assert.h>

static const size_t ARRAYSIZE = 1UL<<30;

void init(int* A)
{
    for (size_t i = 0; i < ARRAYSIZE; ++i)
        A[i] = i;
}

size_t agg(const int* A)
{
    size_t sum = 0;
    for (size_t i = 0; i < ARRAYSIZE; ++i)
        sum += A[i];
    return sum;
}

int main()
{
    assert(sizeof(int) == 4);
    shm_unlink("/cowtest");
    printf("ARRAYSIZE: …

我能看到如何做到这一点的唯一方法是尝试访问它并捕获抛出的异常(如果它不存在).

bool exists()
{
    using namespace boost::interprocess;
    try
    {
        managed_shared_memory segment(open_only, kSharedMemorySegmentName);
        return segment.check_sanity();
    } 
    catch (const std::exception &ex) {
        std::cout << "managed_shared_memory ex: "  << ex.what();
    }
    return false;
}

有没有更好的办法？

所以我试图在Julia中优化数组操作,但是注意到偶尔我的矩阵会出现相当大的错误.我还注意到存在同时写入Julia中SharedArray的相同索引的可能性.我想知道朱莉娅是否可以安全地处理它.如果没有,我怎么能够处理它？

这是我的问题的基本示例

for a list of arbitrary x,y indexes in array J
    j[x,y] += some_value
end

Julia可以处理这种情况,或者像C一样,是否存在覆盖数据的可能性.他们在朱莉娅的原子行动是为了弥补吗？

嘿我正在尝试在两个进程之间创建一个共享对象.并尝试读取和更改每个进程中的值.这是我的简单结构.

编辑:我在我的结构中添加了一个构造函数.

struct shared{
    shared(){
        value = 10;
        name = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    }
    int value;
    string name;
};

我试过在调用fork()之前和之后调用shmat()但是没有任何改变它仍然给出了分段错误.

编辑:并在shmat()后添加一个检查,看看它是否失败.

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <iostream>
#include <sys/shm.h>
#include <string.h>

using namespace std;

struct shared{
    shared(){
        value = 10;
        name = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    }
    int value;
    string name;
};

int main(){
    int shm_id = shmget(IPC_PRIVATE,sizeof(shared),0);

    if(shm_id == -1){
        cout<<"shmget() failed "<<endl;
        return -1;
    }
    pid_t pid = fork();
    if(pid == -1){
        cout<<"fork() failed "<<endl;
        return -2;
    }

    shared* sharedPtr = …