我需要dict在多个进程之间共享一个对象。每个进程在运行时都会读取或修改现有项目和/或将新项目添加到字典中。我正在使用manager来自的对象multiprocessing类似于此代码的
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)\nRun Code Online (Sandbox Code Playgroud)\n\n然而,对于我的特定使用来说,它非常慢。除了 Manager 比共享内存慢这一事实(根据python doc)之外,更重要的问题是在我的应用程序中,每个进程一次仅读取/修改/添加字典的一项,而没有任何事情可做与其余的。因此,我想知道是否有一种方法可以仅锁定特定项目,而不是锁定整个 dict 对象(这会导致速度大幅下降 …
进程 A 使用 shmget 创建了共享内存“1234”。此后,进程 A 使用 shmat 将内存附加到自身。
进程 B 还使用 shmat 将与“1234”对应的共享内存附加到自身。
现在“附加”到底是什么意思?是否存在同一内存的两个副本?如果不是,那么这段记忆到底存在于哪里?
编辑:太多的信息会分散人们的注意力,所以我几乎删除了所有内容。这是在 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 进行读/写时,预期会收到某种错误消息,表明它无法访问它,因为它已被锁定。
实际发生的情况:第二个应用程序访问它没有问题。
我想指定一个属性,该属性是一个用于在函数中进行操作的数组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)
知道如何让它发挥作用吗?对于这个用例,我应该使用更好的模式吗?谢谢提前!
我有一个结构,我想在多个线程之间作为不可变引用共享。我正在使用“Arc”来做到这一点,但为了让 Arc 工作,我必须为我的结构实现发送和同步特征。问题就在这里,Rust Book 中写到“手动实现发送和同步是不安全的”。
解决这个问题的办法是什么?
是否有其他方法可以在多个线程之间共享不可变引用?
我正在使用 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
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) 有没有办法释放共享多处理数组使用的内存?下面的代码片段创建了大约 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) I\xe2\x80\x99m 尝试创建 Numpy 数组,该数组可以被同一台机器上的其他进程极快地访问。经过大量研究和测试,我决定尝试使用 Python 3.8 共享内存来实现这一目标,希望使用共享内存可以允许以亚毫秒的速度在进程之间共享大型 numpy 数组。
\n实现将是这样的:
\nimport 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[:]\nRun Code Online (Sandbox Code Playgroud)\nimport 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()\nRun Code Online (Sandbox Code Playgroud)\n但这里有一个瓶颈。为了在第一个进程上创建共享 numpy 数组,我需要使用:
\nshm_arr[:] = arr[:]\nRun Code Online (Sandbox Code Playgroud)\n这意味着有一个从arr到 的内存复制操作 …
我的应用程序中需要 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) shared-memory ×10
python ×2
c ×1
c++ ×1
concurrency ×1
dictionary ×1
immutability ×1
ipc ×1
locking ×1
mpi ×1
numa ×1
numpy ×1
python-3.8 ×1
python-3.x ×1
rust ×1
swift4 ×1
unsafe ×1