标签: shared-memory

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

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

有任何想法吗？

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

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

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

以下代码使用multiprocessing's Array跨进程共享大量unicode字符串.如果我使用c_wchar_p类型,子进程的内存使用量大约是父进程中使用的内存的四分之一(如果我更改数组中的条目数量,则数量会发生变化).

但是,如果我使用ctypes.Structure单个c_wchar_p字段,则子进程的内存使用量是常量且非常低,而父进程的内存使用量则翻倍.

import ctypes
import multiprocessing
import random
import resource
import time

a = None

class Record(ctypes.Structure):
    _fields_ = [('value', ctypes.c_wchar_p)]
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return '(%s)' % (self.value,)

def child(i):
    while True:
        print "%ik memory used in child %i: %s" % (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024, i, a[i])
        time.sleep(1)
        for j in xrange(len(a)):
            c = a[j]

def main():
    global a
    # uncomment this line and comment the …

• 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 …

这是我第一次在这里发帖提问,我通常会在档案中找到答案,但这次我很难过.

我使用来自使用Windows Driver Kit的供应商的一些代码从操纵杆中获取数据.数据采用具有6个元素的数组形式(它是6个自由度的鼠标).

我已经编写了需要抓取数据的代码,而且它是用C++编写的......它使用标准库很多用向量而不是.似乎使用WDK的标准库是一个很大的痛苦,我花了几天试图上班但失败了.我的下一个想法是使用boost :: interprocess,但由于同样的原因,这很难与WDK一起使用.

我想知道是否有办法在C进程和C++进程之间共享内存.我想使用C程序将数组写入内存并从C++程序中读取.它需要发生得非常快,应该有一种方法可以确保我不会在写入(mutex？)中读取它.

欢迎任何想法或建议.

编辑 我做了一个DLL,现在我只有一个DLL,它有一个getValues()函数,我可以从我的C++项目调用.我不得不使用pimpl成语来隐藏c的东西.谢谢你的帮助!

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

如果我在整个区域上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.

问候贵族社区,

我想要以下循环:

for(i = 0; i < MAX; i++)
    A[i] = B[i] + C[i];

这将在使用线程的共享内存四核计算机上并行运行.以下两个备选方案正在考虑由这些线程执行的代码,其中tid是线程的ID:0,1,2或3.

(为简单起见,假设MAX是4的倍数)

选项1:

for(i = tid; i < MAX; i += 4)
    A[i] = B[i] + C[i];

选项2:

for(i = tid*(MAX/4); i < (tid+1)*(MAX/4); i++)
    A[i] = B[i] + C[i];

我的问题是,是否有一个比另一个更有效,为什么？

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

这是我的问题的基本示例

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

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

这里有一个基准测试代码来说明我的问题:

import numpy as np
import multiprocessing as mp
# allocate memory
%time temp = mp.RawArray(np.ctypeslib.ctypes.c_uint16, int(1e8))
Wall time: 46.8 ms
# assign memory, very slow
%time temp[:] = np.arange(1e8, dtype = np.uint16)
Wall time: 10.3 s
# equivalent numpy assignment, 100X faster
%time a = np.arange(1e8, dtype = np.uint16)
Wall time: 111 ms

基本上我想要在多个进程之间共享一个numpy数组,因为它很大且只读.这种方法效果很好,不需要额外的副本,并且过程的实际计算时间也很好.但是创建共享阵列的开销是巨大的.

这篇文章提供了一些很好的见解,为什么某些初始化数组的方法很慢(请注意,在上面的例子中,我使用的是更快的方法).但这篇文章并没有真正描述如何真正提高速度,使其像性能一样难以捉摸.

有没有人对如何提高速度有任何建议？一些cython代码是否有意义分配数组？

我正在使用Windows 7 x64系统.