如何在不使用多个进程的情况下将 python 对象保留在 RAM 中?
How can I keep a python object in RAM, without using multiple processes?
我正在使用我无法控制的外部程序,它有时会调用我可以指定的子进程,传递一些参数并在完成后检查其退出状态。
我希望这个程序调用的子进程是一个 python 3 执行一些计算的脚本
使用构造起来非常昂贵且非常大的对象。因为对象的构造非常昂贵,我不想每次这个外部程序调用脚本时都构造它,而且因为它需要相当多的 space ,所以每次将它腌制到磁盘并加载它很慢。
我目前的解决方案是有两个进程,一个构造对象并在需要时执行计算,另一个进程由外部程序调用,其唯一真正的 objective 是通过套接字与第一个进程通信并请求它执行任务。
第一个过程的代码大致如下所示:
# process1.py, performs calculations
import socket
import pickle
def do_expensive_calculations(large_object, data):
# some expensive calculations
return value
class LargeAndSlow:
def __init__(self):
# some code
if __name__ == '__main__':
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.bind('ADDRESS')
s.listen(1)
large_object = LargeAndSlow()
while True:
(conn, address) = s.accept()
data = pickle.loads(conn.recv(4096))
value = do_expensive_calculations(large_object, data)
conn.send(pickle.dumps(value))
第二个(外部程序调用的那个)像这样:
# process2.py
import sys
import socket
import pickle
def value_is_correct(value):
# check if value is correct
return is_correct
if __name__ == '__main__':
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect('ADDRESS')
s.send(pickle.dumps(sys.argv))
value = pickle.loads(s.recv(4096))
if value_is_correct(value):
s.close()
sys.exit(0)
else:
s.close()
sys.exit(1)
然而,这个解决方案实际上比每次都构造对象要慢,我怀疑这是由于同时拥有多个 python 进程 运行 并通过 UNIX 套接字进行通信的开销所致(但是,我可能是错的,也许我只是以一种非常低效的方式编码)。
是否有更快、更有效的解决方案?
您可以创建一个 ram 磁盘分区并将其挂载为常规文件系统。在 Unix 系统上,您可以使用 tmpfs
来达到目的。
从程序的角度来看,您的文件看起来像一个普通文件。然而,OS 会将其存储在内存中。
请记住,您可能会(或可能不会)注意到的速度提升取决于许多因素。 I/O 可能是其中之一,tmpfs
会有所帮助。然而,瓶颈可能是其他原因,例如 pickling/unpickling 进程。
如果您使用的是 Python 3.8,Python 的多处理库已经支持 SharedMemory
class。它可以让多个进程直接访问同一个内存区域。因此,在不同进程之间移动大对象不会产生开销。详情可参考Python's document
如果您没有使用 Python 3.8,有一个 Python 包 SharedArray 具有类似的功能。
我正在使用我无法控制的外部程序,它有时会调用我可以指定的子进程,传递一些参数并在完成后检查其退出状态。
我希望这个程序调用的子进程是一个 python 3 执行一些计算的脚本 使用构造起来非常昂贵且非常大的对象。因为对象的构造非常昂贵,我不想每次这个外部程序调用脚本时都构造它,而且因为它需要相当多的 space ,所以每次将它腌制到磁盘并加载它很慢。
我目前的解决方案是有两个进程,一个构造对象并在需要时执行计算,另一个进程由外部程序调用,其唯一真正的 objective 是通过套接字与第一个进程通信并请求它执行任务。
第一个过程的代码大致如下所示:
# process1.py, performs calculations
import socket
import pickle
def do_expensive_calculations(large_object, data):
# some expensive calculations
return value
class LargeAndSlow:
def __init__(self):
# some code
if __name__ == '__main__':
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.bind('ADDRESS')
s.listen(1)
large_object = LargeAndSlow()
while True:
(conn, address) = s.accept()
data = pickle.loads(conn.recv(4096))
value = do_expensive_calculations(large_object, data)
conn.send(pickle.dumps(value))
第二个(外部程序调用的那个)像这样:
# process2.py
import sys
import socket
import pickle
def value_is_correct(value):
# check if value is correct
return is_correct
if __name__ == '__main__':
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect('ADDRESS')
s.send(pickle.dumps(sys.argv))
value = pickle.loads(s.recv(4096))
if value_is_correct(value):
s.close()
sys.exit(0)
else:
s.close()
sys.exit(1)
然而,这个解决方案实际上比每次都构造对象要慢,我怀疑这是由于同时拥有多个 python 进程 运行 并通过 UNIX 套接字进行通信的开销所致(但是,我可能是错的,也许我只是以一种非常低效的方式编码)。
是否有更快、更有效的解决方案?
您可以创建一个 ram 磁盘分区并将其挂载为常规文件系统。在 Unix 系统上,您可以使用 tmpfs
来达到目的。
从程序的角度来看,您的文件看起来像一个普通文件。然而,OS 会将其存储在内存中。
请记住,您可能会(或可能不会)注意到的速度提升取决于许多因素。 I/O 可能是其中之一,tmpfs
会有所帮助。然而,瓶颈可能是其他原因,例如 pickling/unpickling 进程。
如果您使用的是 Python 3.8,Python 的多处理库已经支持 SharedMemory
class。它可以让多个进程直接访问同一个内存区域。因此,在不同进程之间移动大对象不会产生开销。详情可参考Python's document
如果您没有使用 Python 3.8,有一个 Python 包 SharedArray 具有类似的功能。