标签: shared-memory

我已经看过我能找到的唯一一个类似的帖子了,但这不是我想要的.

基本上,我正在尝试使用分叉运行Odd-Even Sort,因此孩子运行赔率并且父母运行平均值.这两者都需要共享矢量inputValues,以及布尔排序.

以下代码没有任何失败的共享内存尝试,只是使用搜索算法的分叉的基本框架:

while(!sorted)
{
    pID = fork();
    sorted = true;
    cout << "Sort set to TRUE." << endl;

    if(pID == 0)
    {
        int num = 1;
        cout << "Child swap run" << endl;
        Swap((void *) num);
        cout << "Status: " << ((sorted) ? "SORTED" : "UNSORTED") << endl;
        exit(0);
    }
    else if(pID < 0)
    {
        cout << "Failed to fork." << endl;
        exit(1);
    }
    else
    {
        wpid = waitpid(pID, &status, waitStatus);
        int num = 0;
        cout …

假设我创建了一个信号量.如果我分叉一堆子进程,它们还会使用相同的信号量吗？

另外,假设我创建了一个内部和分叉信号量的结构.所有子进程是否仍然使用相同的信号量？如果没有,将结构+信号量存储在共享内存中是否允许子进程使用相同的信号量？

我真的很困惑我的分叉子进程如何使用相同的信号量.

#include <stdio.h> 
#include <sys/shm.h> 
#include <sys/stat.h> 
#include <string>
#include <vector>
#include <iostream>

using namespace std;

struct LOCK {
  string name;
  string type;
  vector <string> pids;
};

int main () 

{

  int segment_id; 

  LOCK* shared_memory; 

  struct shmid_ds shmbuffer; 

  int segment_size; 

  const int shared_segment_size = 0x6400; 



  /* Allocate a shared memory segment.  */ 

  segment_id = shmget (IPC_PRIVATE, shared_segment_size, 

                     IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR); 

  /* Attach the shared memory segment.  */ 

  shared_memory = (LOCK*) shmat (segment_id, 0, 0); 

  printf ("shared memory …

以下代码使用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 …

我正在开发一个可以同时在同一台计算机上多次实例化的应用程序.每个JVM都不必要地在自己的内存中加载应用程序类,因为所有应用程序的类都是相同的.

我在这里和这里读到了CDS ,但它似乎只对JDK类有效.

如何在JVM之间共享应用程序类的数据？

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

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

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

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

欢迎任何想法或建议.

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

我最近一直在学习Python多处理,并遇到了障碍.我有一个稀疏的SciPy数组(CSC格式),我需要在5个工作进程之间以只读格式共享.我已经读过这个和这个(numpy-shared),但这似乎只适用于密集类型.

如何在不复制(或使用最少复制)5个多处理过程对象的情况下共享scipy.sparse.csc_matrix()？即使是numpy-shared方法似乎也需要复制整个数组,即便如此,我也不能将scipy.sparse转换为mp.Array().任何人都可以帮我指出正确的方向吗？

谢谢!

问候贵族社区,

我想要以下循环:

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];

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

在关于data.table和并行计算的帖子之后,我试图找到一种方法来实现平行操作data.table.

我有一个data.table包含4百万行14个观察值并希望在公共内存中共享它,以便可以通过使用"并行"包来并行化它上的操作,parLapply 而无需为集群中的每个节点复制表(什么parLapply).目前,移动data.table周围的成本大于并行计算的好处.

我发现"bigmemory"-package是共享内存的答案,但它没有维护数据的"data.table"结构.所以有人知道一种方法:

1)放入data.table共享内存

2)通过这样做来维护数据的"data.table"结构

3)对此使用并行处理data.table？

提前致谢!

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

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系统.