Python 中的并行性

Question

在 Python 中实现并行性的选项有哪些？我想要对一些非常大的栅格执行大量 CPU 密集型计算，并且想要并行化它们。由于具有 C 语言背景，我熟悉三种并行方法：

1. 消息传递进程，可能分布在集群中，例如MPI。
2. 显式共享内存并行，使用pthreads或fork()、pipe()等。 al
3. 使用OpenMP实现隐式共享内存并行。

决定使用方法是一种权衡的过程。

在 Python 中，有哪些可用的方法以及它们的特点是什么？是否有可集群的MPI克隆？实现共享内存并行性的首选方法是什么？我听说过有关GIL 的问题，以及tasklet 的问题。

简而言之，在选择 Python 中的不同并行化策略之前，我需要了解哪些内容？

Answer 1

通常，您描述的是 CPU 密集型计算。这不是Python的强项。从历史上看，两者都不是多处理。

主流 Python 解释器中的线程一直受到可怕的全局锁的统治。新的 multiprocessing API 解决了这个问题，并提供了带有管道和队列等的工作池抽象。

您可以使用 C 或 Cython，并使用 Python 作为粘合剂。

Answer 2

新的 (2.6) multiprocessing 模块是正确的选择。它使用子进程，解决了GIL问题。它还抽象了一些本地/远程问题，因此可以稍后选择在本地运行代码或分布在集群上。我上面链接的文档需要仔细阅读，但应该为入门提供良好的基础。

Answer 3

Ray 是一个用于执行此操作的优雅（且快速）的库。

并行化 Python 函数的最基本策略是使用 @ray.remote 装饰器声明函数。然后就可以异步调用了。

import ray
import time

# Start the Ray processes (e.g., a scheduler and shared-memory object store).
ray.init(num_cpus=8)

@ray.remote
def f():
    time.sleep(1)

# This should take one second assuming you have at least 4 cores.
ray.get([f.remote() for _ in range(4)])

您还可以使用 actors 并行化有状态计算，再次使用 @ray.remote< /code> 装饰器。

# This assumes you already ran 'import ray' and 'ray.init()'.

import time

@ray.remote
class Counter(object):
    def __init__(self):
        self.x = 0

    def inc(self):
        self.x += 1

    def get_counter(self):
        return self.x

# Create two actors which will operate in parallel.
counter1 = Counter.remote()
counter2 = Counter.remote()

@ray.remote
def update_counters(counter1, counter2):
    for _ in range(1000):
        time.sleep(0.25)
        counter1.inc.remote()
        counter2.inc.remote()

# Start three tasks that update the counters in the background also in parallel.
update_counters.remote(counter1, counter2)
update_counters.remote(counter1, counter2)
update_counters.remote(counter1, counter2)

# Check the counter values.
for _ in range(5):
    counter1_val = ray.get(counter1.get_counter.remote())
    counter2_val = ray.get(counter2.get_counter.remote())
    print("Counter1: {}, Counter2: {}".format(counter1_val, counter2_val))
    time.sleep(1)

与 multiprocessing 模块相比，它具有许多优点：

• 相同的代码在单个多核机器以及大型集群。
• 使用 共享内存和高效序列化。
• 您可以并行化 Python 函数（使用任务）和 Python 类（使用 actor）。
• 错误消息传播得很好。

Ray 是我一直在帮助开发的一个框架。

Answer 4

根据您需要处理的数据量以及您打算使用多少个 CPU/机器，在某些情况下最好用 C（如果您想使用 jython/IronPython，则使用 Java/C#）编写一部分数据

。您可以发现，这可能比在 8 个 CPU 上并行运行更能提高性能。

Answer 5

有很多包可以做到这一点，正如其他人所说，最合适的是多处理，特别是“Pool”类。

通过 parallel python 可以获得类似的结果，此外它还被设计用于集群。

不管怎样，我会说使用多处理。