在新进程中执行 python 代码比在主进程中慢得多

Question

我开始在python 中了解multiprocessing，我注意到相同的代码在主进程中的执行速度比在使用multiprocessing 模块创建的进程中要快得多。

这是我的代码的简化示例，我首先在 main process 上执行代码并打印前 10 次计算的时间和总计算的时间。并且在new process 上执行相同的代码（这是一个长时间运行的过程，我可以随时发送new_pattern）。

import multiprocessing
import random
import time


old_patterns = [[random.uniform(-1, 1) for _ in range(0, 10)] for _ in range(0, 2000)]
new_patterns = [[random.uniform(-1, 1) for _ in range(0, 10)] for _ in range(0, 100)]


new_pattern_for_processing = multiprocessing.Array('d', 10)
there_is_new_pattern = multiprocessing.Value('i', 0)
queue = multiprocessing.Queue()


def iterate_and_add(old_patterns, new_pattern):
    for each_pattern in old_patterns:
        sum = 0
        for count in range(0, 10):
            sum += each_pattern[count] + new_pattern[count]


print_count_main_process = 0
def patt_recognition_main_process(new_pattern):
    global print_count_main_process
    # START of same code on main process
    start_main_process_one_patt = time.time()
    iterate_and_add(old_patterns, new_pattern)
    if print_count_main_process < 10:
        print_count_main_process += 1
        print("Time on main process one pattern:", time.time() - start_main_process_one_patt)
    # END of same code on main process


def patt_recognition_new_process(old_patterns, new_pattern_on_new_proc, there_is_new_pattern, queue):
    print_count = 0
    while True:
        if there_is_new_pattern.value:
            #START of same code on new process
            start_new_process_one_patt = time.time()
            iterate_and_add(old_patterns, new_pattern_on_new_proc)
            if print_count < 10:
                print_count += 1
                print("Time on new process one pattern:", time.time() - start_new_process_one_patt)
            #END of same code on new process
            queue.put("DONE")
            there_is_new_pattern.value = 0


if __name__ == "__main__":
    start_main_process = time.time()
    for new_pattern in new_patterns:
        patt_recognition_main_process(new_pattern)
    print(".\n.\n.")
    print("Total Time on main process:", time.time() - start_main_process)

    print("\n###########################################################################\n")

    start_new_process = time.time()
    p1 = multiprocessing.Process(target=patt_recognition_new_process, args=(old_patterns, new_pattern_for_processing, there_is_new_pattern, queue))
    p1.start()
    for new_pattern in new_patterns:
        for idx, n in enumerate(new_pattern):
            new_pattern_for_processing[idx] = n
        there_is_new_pattern.value = 1
        while True:
            msg = queue.get()
            if msg == "DONE":
                break
    print(".\n.\n.")
    print("Total Time on new process:", time.time()-start_new_process)

这是我的结果：

Time on main process one pattern: 0.0025289058685302734
Time on main process one pattern: 0.0020127296447753906
Time on main process one pattern: 0.002008199691772461
Time on main process one pattern: 0.002511262893676758
Time on main process one pattern: 0.0020067691802978516
Time on main process one pattern: 0.0020036697387695312
Time on main process one pattern: 0.0020072460174560547
Time on main process one pattern: 0.0019974708557128906
Time on main process one pattern: 0.001997232437133789
Time on main process one pattern: 0.0030074119567871094
.
.
.
Total Time on main process: 0.22810864448547363

###########################################################################

Time on new process one pattern: 0.03462791442871094
Time on new process one pattern: 0.03308463096618652
Time on new process one pattern: 0.034590721130371094
Time on new process one pattern: 0.033623456954956055
Time on new process one pattern: 0.03407788276672363
Time on new process one pattern: 0.03308820724487305
Time on new process one pattern: 0.03408670425415039
Time on new process one pattern: 0.0345921516418457
Time on new process one pattern: 0.03710794448852539
Time on new process one pattern: 0.03358912467956543
.
.
.
Total Time on new process: 4.0528037548065186

为什么执行时间差别这么大？

Answer 1

有点微妙，但问题出在

new_pattern_for_processing = multiprocessing.Array('d', 10)

它不包含 python float 对象，它包含原始字节，在这种情况下足以容纳 10 个 8 字节机器级别 double。当您读取或写入此数组时，python 必须将 float 转换为 double 或反之。如果您只读取或写入一次，这没什么大不了的，但是您的代码会在循环中执行多次，并且这些转换占主导地位。

为了确认，我曾经将机器级数组复制到 python 浮点列表中，并让该过程对其进行处理。现在它的速度与父级相同。我的更改只在一个函数中

def patt_recognition_new_process(old_patterns, new_pattern_on_new_proc, there_is_new_pattern, queue):
    print_count = 0
    while True:
        if there_is_new_pattern.value:
            local_pattern = new_pattern_on_new_proc[:]
            #START of same code on new process
            start_new_process_one_patt = time.time()
            #iterate_and_add(old_patterns, new_pattern_on_new_proc)
            iterate_and_add(old_patterns, local_pattern)
            if print_count < 10:
                print_count += 1
                print("Time on new process one pattern:", time.time() - start_new_process_one_patt)
            #END of same code on new process
            there_is_new_pattern.value = 0
            queue.put("DONE")

Answer 2

在这种特殊情况下，您似乎在另一个进程中执行顺序执行，而不是并行化您的算法。这会产生一些开销。

流程创建本身需要时间。但这并不是全部。您还在队列中传输数据并使用管理器代理。这些都是实践中的队列，或者实际上是两个队列和另一个进程。与使用内存中的数据副本相比，队列非常非常慢。

如果您使用您的代码，在另一个进程中执行它并使用队列来传入和传出数据，它总是比较慢。从性能的角度来看，这使得它毫无意义。尽管如此，这样做可能还有其他原因，例如，如果您的主程序需要执行其他操作，例如等待 IO。

如果您想要提高性能，您应该改为创建多个流程并拆分您的算法，以便您在不同的流程中处理您的部分范围，从而并行工作。如果您想让一组工作进程准备好等待更多工作，您也可以考虑Multiprocessing.Pool。这将减少进程创建开销，因为您只执行一次。在 Python 3 中，您还可以使用 ProcessPoolExecutor。

并行处理很有用，但很少有蛇油可以轻松解决所有问题。为了充分利用它，您需要重新设计程序以最大化并行处理并最小化队列中的数据传输。