标签: shared-memory

在多处理中使用项目级锁定共享字典(无需管理器)

我需要dict在多个进程之间共享一个对象。每个进程在运行时都会读取或修改现有项目和/或将新项目添加到字典中。我正在使用manager来自的对象multiprocessing类似于此代码的

\n\n
import multiprocessing as mp\n\ndef init_d(d, states):\n    for s in states:\n        if tuple(list(s) + [0]) not in d:\n            for i in range(4):\n                d[tuple(list(s) + [i])] = 0\n\nif __name__ == \'__main__\':\n    with mp.Manager() as manager:\n        master_d = manager.dict()\n\n        states1 = [(1, 2), (3, 4)]\n        states2 = [(1, 2), (5, 6)]\n\n        p1 = mp.Process(target=init_d, args=(master_d, states1))\n        p2 = mp.Process(target=init_d, args=(master_d, states2))\n        p1.start()\n        p2.start()\n        p1.join()\n        p2.join()\n\n        print(master_d)\n
Run Code Online (Sandbox Code Playgroud)\n\n

然而,对于我的特定使用来说,它非常慢。除了 Manager 比共享内存慢这一事实(根据python doc)之外,更重要的问题是在我的应用程序中,每个进程一次仅读取/修改/添加字典的一项,而没有任何事情可做与其余的。因此,我想知道是否有一种方法可以仅锁定特定项目,而不是锁定整个 dict 对象(这会导致速度大幅下降 …

python dictionary shared-memory multiprocessing

5
推荐指数
0
解决办法
860
查看次数

Linux 中的共享内存在幕后是如何工作的?

进程 A 使用 shmget 创建了共享内存“1234”。此后,进程 A 使用 shmat 将内存附加到自身。

进程 B 还使用 shmat 将与“1234”对应的共享内存附加到自身。

现在“附加”到底是什么意思?是否存在同一内存的两个副本?如果不是,那么这段记忆到底存在于哪里?

shared-memory

5
推荐指数
1
解决办法
3064
查看次数

使用 python,如何在两个完全独立的 python 解释器之间传递锁?

编辑:太多的信息会分散人们的注意力,所以我几乎删除了所有内容。这是在 Windows 上,Python 3.6 使用 mmap 和 msvcrt

一个 python 应用程序中的代码:

fd = os.open(r'C:\somefile', os.O_CREAT | os.O_RDWR)
mm_file = mmap.mmap(fd, 4096, access=mmap.ACCESS_WRITE)
msvcrt.locking(fd, msvcrt.LK_LOCK, 4096)
Run Code Online (Sandbox Code Playgroud)

当第二个应用程序尝试打开 C:\somefile 进行读/写时,预期会收到某种错误消息,表明它无法访问它,因为它已被锁定。

实际发生的情况:第二个应用程序访问它没有问题。

locking ipc shared-memory python-3.x

5
推荐指数
0
解决办法
712
查看次数

同时访问<地址>,但修改需要独占访问

我想指定一个属性,该属性是一个用于在函数中进行操作的数组myFunc,但我收到此错误。这是我的代码草图。

self.data = MyObject()

func myFunc(x: inout [Int], y: inout [[Int]]) {
    //manipulation code to x and y
}

myFunc(x: &self.data.array1, y: &self.data.array2)
myFunc(x: &self.data.array3, y: &self.data.array4)
Run Code Online (Sandbox Code Playgroud)

知道如何让它发挥作用吗?对于这个用例,我应该使用更好的模式吗?谢谢提前!

shared-memory swift4

5
推荐指数
1
解决办法
6260
查看次数

如何在 Rust 中的多个线程之间共享结构的不可变引用?

我有一个结构,我想在多个线程之间作为不可变引用共享。我正在使用“Arc”来做到这一点,但为了让 Arc 工作,我必须为我的结构实现发送和同步特征。问题就在这里,Rust Book 中写到“手动实现发送和同步是不安全的”。

解决这个问题的办法是什么?

是否有其他方法可以在多个线程之间共享不可变引用?

concurrency unsafe immutability shared-memory rust

5
推荐指数
1
解决办法
1455
查看次数

Cloud Run 中的共享缓存对象存储在哪里?

我正在使用 Cloud Run 创建数据提取管道。每次通过 Pub Sub 将文件放入 GCS 存储桶时,我的 Cloud Run api 都会被调用。我需要加载一些元数据,其中包含我正在摄取的数据的文本。此元数据很少更改。我显然不想在每次执行时将其重新加载到内存中。我最好的选择是什么?到目前为止我能够研究的是:

选项1

如果在每个服务请求上重新创建对象的成本很高,您还可以将对象缓存在内存中。将其从请求逻辑转移到全局范围会带来更好的性能。 https://cloud.google.com/run/docs/tips#run_tips_global_scope-java

在此链接给出的示例中,heavyComputation 函数仅在冷启动时调用一次吗?如果我需要在元数据更新时偶尔重新触发此功能怎么办?我还发现以下信息令人不安,因为它似乎说不能保证其他实例会重用该对象。

在 Cloud Run 中,您不能假设服务状态在请求之间保留。但是,Cloud Run 确实会重用各个容器实例来服务持续的流量,因此您可以在全局范围内声明一个变量,以允许在后续调用中重用其值。无法提前知道是否有任何单独的请求能够从这种重用中获益。

选项2

使用 Redis 或云内存存储之类的东西,只要有变化,云功能就会更新。所有云运行 api 的实例都从 Redis 中提取元数据信息。这会比选项 1 的性能更低还是更高吗?这还有其他缺点吗?

如果还有其他更好的方法可以做到这一点,我会很感兴趣。

更新 1:我更多地考虑了这一点,由于每个租户的元数据都会有所不同,并且每次调用云运行代码都会为一个租户摄取一个文件,因此加载所有租户是一个坏主意每次执行时的元数据,即使已缓存。不过,我可能会在每个租户的项目中运行单独的云。

shared-memory data-ingestion google-cloud-memorystore google-cloud-run

5
推荐指数
1
解决办法
5928
查看次数

同步对 MPI3 共享内存的访问:该代码是否能保证按 MPI 标准工作?

MPI-3 标准引入了共享内存,共享该内存的所有进程都可以读取和写入该内存,而无需调用 MPI 库。虽然有使用共享或非共享内存的单方面通信的示例,但我没有找到太多有关如何通过直接访问正确使用共享内存的信息。

我最终做了这样的事情,效果很好,但我想知道 MPI 标准是否保证它总是有效?

// initialization:
MPI_Comm comm_shared;
MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, i_mpi, MPI_INFO_NULL, &comm_shared);

// allocation
const int N_WIN=10;
const int mem_size = 1000*1000;
double* mem[10];
MPI_Win win[N_WIN];
for (int i=0; i<N_WIN; i++) {   // I need several buffers.
    MPI_Win_allocate_shared( mem_size, sizeof(double), MPI_INFO_NULL, comm_shared, &mem[i], &win[i] );
    MPI_Win_lock_all(0, win);
}

while(1) {
    MPI_Barrier(comm_shared);
    ... // write anywhere on shared memory
    MPI_Barrier(comm_shared);
    ... // read on shared memory written by other processes
}

// deallocation
for (int i=0; i<N_WIN; …
Run Code Online (Sandbox Code Playgroud)

c parallel-processing mpi shared-memory numa

5
推荐指数
2
解决办法
918
查看次数

Python多重处理释放共享数组使用的内存

有没有办法释放共享多处理数组使用的内存?下面的代码片段创建了大约 1 GiB 共享内存的内存块,然后该内存块被阻止用于脚本的其余部分。有没有办法在同一脚本运行期间释放该内存?

我尝试删除所有引用并通过 gc.collect() 调用垃圾收集器,但这似乎对运行时脚本的内存使用没有任何影响。

import psutil
import gc
import ctypes as cty
import multiprocessing as mpc
import os

def bytes_to_GiB_MiB(n_bytes):
    return n_bytes/2**30, (n_bytes%(2**30))/2**20
    
def print_mem_usage():
    process = psutil.Process(os.getpid()) 
    print "Script Mem Usage {:} GiB {:} MiB".format(*bytes_to_GiB_MiB(process.memory_info().rss))
    return process.memory_info().rss    
    
if __name__=="__main__":
    t_N = 5000
    N=150
    Shape_spl = (t_N+4, N,N) 
    mem0 = print_mem_usage()
    C_shared = mpc.Array(cty.c_double, N*N*(t_N+4))
    mem1 = print_mem_usage()
    print "Mem Difference is {:} GiB {:} MiB".format(*bytes_to_GiB_MiB(mem1-mem0))
    del C_shared
    gc.collect()
    # Do something here such that the memory …
Run Code Online (Sandbox Code Playgroud)

python shared-memory multiprocessing

5
推荐指数
1
解决办法
532
查看次数

创建共享内存Numpy ndarray,无需内存复制

I\xe2\x80\x99m 尝试创建 Numpy 数组,该数组可以被同一台机器上的其他进程极快地访问。经过大量研究和测试,我决定尝试使用 Python 3.8 共享内存来实现这一目标,希望使用共享内存可以允许以亚毫秒的速度在进程之间共享大型 numpy 数组。

\n

实现将是这样的:

\n
    \n
  • 在第一个 ipython shell 上(在第一个进程上):
  • \n
\n
import time\nimport numpy as np\nfrom multiprocessing.shared_memory import SharedMemory\n\narr = np.random.randint(0, 255, (5000, 5000, 4), dtype=np.uint8)\nshm = SharedMemory(create=True, size=arr.nbytes)\n\nshm_arr = np.ndarray(arr.shape, dtype=arr.dtype, buffer=shm.buf)\nshm_arr[:] = arr[:]\n
Run Code Online (Sandbox Code Playgroud)\n
    \n
  • 在第二个 ipython shell 上(在第二个进程上):
  • \n
\n
import numpy as np\nimport time\nfrom multiprocessing.shared_memory import SharedMemory\n\nshm = SharedMemory(name=\'test\')\nshm_arr = np.ndarray([5000, 5000, 4], dtype=np.uint8, buffer=shm.buf)\nshm.close()\n
Run Code Online (Sandbox Code Playgroud)\n

但这里有一个瓶颈。为了在第一个进程上创建共享 numpy 数组,我需要使用:

\n
shm_arr[:] = arr[:]\n
Run Code Online (Sandbox Code Playgroud)\n

这意味着有一个从arr到 的内存复制操作 …

numpy shared-memory multiprocessing python-3.8

5
推荐指数
0
解决办法
921
查看次数

有没有更好的方法来处理 C++ 中共享内存的竞争条件?

我的应用程序中需要 IPC。我尝试过socket,但速度不够快。因此,我使用共享内存来做到这一点。为了同步通信,我使用内存中的标志并在 while 循环中检查它。它可以工作,但是轮询非常耗时,这使得它比套接字的解决方案慢。我的代码中共享内存的实现是shoom。我想在 Windows 和 Mac 上执行此操作,目前正在 Windows 上进行测试。完整的代码如下:

服务器:

#include "include/shoom.h"
#include <stdio.h>
#include <thread>

typedef struct _packet_ {
    uint8_t flag;
    int data;
} _packet;

int main()
{
    int data;
    _packet* ptr;
    shoom::Shm server("test", sizeof(_packet));

    if (server.Create() == shoom::kOK)
    {
        ptr = (_packet*)server.Data();

        while (1)
        {
            while (!ptr->flag)
            {
                std::this_thread::sleep_for(std::chrono::microseconds(100));
            }

            data = ptr->data;
            ptr->flag = 0;

            printf("%d\n", data);
        }
    }

    return 0;
}
Run Code Online (Sandbox Code Playgroud)

客户:

#include "include/shoom.h"
#include <stdio.h>
#include <chrono>
#include <thread>

typedef struct _packet_ …
Run Code Online (Sandbox Code Playgroud)

c++ synchronization shared-memory

5
推荐指数
0
解决办法
442
查看次数