Python многопроцессорность зависает

Question

Я довольно новичок в Python и совершенно новичок в многопроцессорности. Я нашел в Интернете несколько учебных пособий, которые помогут мне понять пакет многопроцессорности.

В моем коде есть набор дифференциальных уравнений с использованием метода RungeKutta4, и я Мне нужно выполнить кучу вычислений с различными начальными условиями.

Сам код работает, но без многопроцессорной обработки это занимает много времени до окончания sh, и я подумал, что было бы идеально использовать параллелизацию, потому что вычисления независимы ... .

Кстати, я использую Anaconda в качестве IDE ..

Поэтому я использовал

import multiprocessing as mp
iterations = np.arange(start,end,step)
pool = mp.Pool(mp.cpu_count())                           # Step 1: Init multiprocessing.Pool()
results = pool.map(rungeKutta4, [k for k in iterations]) # Step 2: apply pool map              
pool.close()                                             # Step 3: close

Когда я запускаю его в Anaconda, я не получаю сообщение об ошибке, он начинает вычислять, но это никогда не останавливается .... Где я go не так?

Заранее спасибо за помощь ...

Лучший

РЕДАКТИРОВАТЬ: я добавил весь код здесь ...

# Python program to implement Runge Kutta method 
# Markus Schmid
# 2020 Appalachian State University
# jupyter nbconvert --to python FILENAME.ipynb

# y" + 2*beta*y' + w0*sin(y) = A + B*cos(w*t)
# Import used libraries
import numpy as np
import math
import matplotlib.pyplot as plt
import time
from matplotlib import rc
rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
rc('text', usetex=True)
import multiprocessing as mp
print("Number of processors: ", mp.cpu_count())
# list for time (x axis) and result (y axis)
result = []
w0 = 10                  # undamped angular frequency of the oscillator
beta = 1
B = 1
A = 0
B = 10
w = 4
theta_init = 0
theta_end = 20
theta_step = 0.1

# initial conditions
t0 = 0
y0 = 0
z0 = 0
t_final = 20                   # final time
h = 0.01                    # fixed step size
n = (int)((t_final - t0)/h)   # datapoints per RK4 iteration

# define functions
def funcf(t, y, z): 
    return (z)
def funcg(t, y, z): 
    return (A+B*math.cos(w*t) - 2*beta*z - w0*math.sin(y))

# Finds value of y for a given x using step size h 
# and initial value y0 at x0. 
def rungeKutta4(y): 
    # Count number of iterations using step size or 
    # step height h 
    t = t0
    z = z0
    n = (int)((t_final - t)/h)  
    for i in range(1, n + 1): 
        # Apply Runge Kutta to find next value of y
        k1 = h * funcf(t, y, z) 
        l1 = h * funcg(t, y, z)  

        k2 = h * funcf(t + 0.5 * h, y + 0.5 * k1, z + 0.5 * l1) 
        l2 = h * funcg(t + 0.5 * h, y + 0.5 * k1, z + 0.5 * l1)  

        k3 = h * funcf(t + 0.5 * h, y + 0.5 * k2, z + 0.5 * l2) 
        l3 = h * funcg(t + 0.5 * h, y + 0.5 * k2, z + 0.5 * l2) 

        k4 = h * funcf(t + h, y + k3, z + l3) 
        l4 = h * funcg(t + h, y + k3, z + l3) 

        # Update next value of y 
        y = y + (1.0 / 6.0)*(k1 + 2 * k2 + 2 * k3 + k4) 
        z = z + (1.0 / 6.0)*(l1 + 2 * l2 + 2 * l3 + l4) 

        #result.append(y)                
        t = t + h # Update next value of t
    return y 

iterations = np.arange(theta_init,theta_end+theta_step,theta_step)   # number iterations for omega sweep

start_time = time.time()
#for k in iterations:     # for serial calculation
#            rungeKutta4(k)
pool = mp.Pool(mp.cpu_count()) # Step 1: Init multiprocessing.Pool()
results = pool.map(rungeKutta4, [k for k in iterations]) # Step 2: apply pool map        
end_time = time.time()            
pool.close()  # Step 3: close
print ("The program took", end_time - start_time, "s to run")

#table = np.array(result).reshape(len(iterations),n)   # rearrange array, 1 row is const. theta0
timer = np.arange(t0,t_final,h) # time array

Answer 1

Мой первоначальный комментарий:

IDE могут взаимодействовать с Python неожиданным образом. Есть несколько упоминаний о неправильной работе многопроцессорных систем в стеках потока. Поэтому, вероятно, лучше всего протестировать ваш скрипт, напрямую вызвав Python из оболочки (cmd.exe в ms- windows).

Вы ответили:

RuntimeError: Была предпринята попытка запустить новый процесс до того, как текущий процесс завершит свою фазу начальной загрузки.

Чтобы multiprocessing хорошо работал на ms- windows, вы должны быть возможность импортировать код в ваш скрипт без побочных эффектов, таких как запуск нового процесса .

Это означает, что вы должны поместить все, кроме импорта и определений функций / классов, в основной блок как в этом примере, вдохновленном документацией:

from multiprocessing import Process

def foo():
    print('hello')

if __name__ == '__main__':
    p = Process(target=foo)
    p.start()

В основном, ms- windows не хватает довольно изящного системного вызова fork(), который существует в UNIX -подобных системах. Таким образом, Python разработчикам пришлось придумать хитрый хак, чтобы multiprocessing работал на ms- windows. См., Например, этот ответ для подробностей.

Редактировать В ms- windows кажется, что также необходимо поместить рабочую функцию в отдельный файл и импортировать это. См. Например здесь .

Answer 2

Я нашел решение заставить его работать в Анаконде.

кроме

if __name__ == '__main__':

функция, которая вызывается (рабочий) , должна быть своей собственной .py файл, который должен быть импортирован в начале ..

Я поместил RK4 в файл RK4.py, который я импортировал в начале, но он не работает, но это открывает новые проблемы в моем случае с передачей значений назад и вперед ...

Answer 3

Добро пожаловать в StackOverflow :)

Ваш код выглядит нормально, и он работает для меня (я python с python3 .6.9), я приложил результаты и конфигурацию ниже.

Вы пытались запустить его в другой python виртуальной среде (за пределами Anaconda)? Как было сказано ранее (в комментарии Рональда) в других IDE есть ошибки с многопроцессорной обработкой python, попробуйте запустить его с помощью командной строки / I python. Ранее я встречал его даже в vscode

Конфигурация:

Результаты: