IPython에서 일부 함수를 실행하는 것이 일반적인 파이썬 함수보다 느립니다.

Question

ipython의 일부 기능을 테스트 중이므로 잘못 생각한 것 같습니다.

일부 수학 연산을 실행하기 위해 3 가지 방법을 테스트 중입니다.

• @parallel.parallel(view=dview, block=True) 및 기능을 사용하여 1 map
• (파이썬 정상적인 기능)
• 3 사용하는 클라이언트의로드 밸런싱 기능을 단일 코어 기능을 사용하여 2

이 코드가 있습니다

from IPython import parallel 
import numpy as np 
import multiprocessing as mp 
import time 

rc = parallel.Client(block=True) 
dview = rc[:] 
lbview = rc.load_balanced_view() 

@parallel.require(np) 
def suma_pll(a, b): 
    return a + b 

@parallel.require(np) 
def producto_pll(a, b): 
    return a * b 

def suma(a, b): 
    return a + b 

def producto(a, b): 
    return a * b 

@parallel.parallel(view=dview, block=True) 
@parallel.require(np) 
@parallel.require(suma_pll) 
@parallel.require(producto_pll) 
def a_calc_pll(a, b): 
    result = [] 
    for i, v in enumerate(a): 
     result.append(
      producto_pll(suma_pll(a[i], a[i]), suma_pll(b[i], b[i]))//100 
     ) 
    return result 

@parallel.require(suma) 
@parallel.require(producto) 
def a_calc_remote(a, b): 
    result = [] 
    for i, v in enumerate(a): 
     result.append(
      producto(suma(a[i], a[i]), suma(b[i], b[i]))//100 
     ) 
    return result 

def a_calc(a, b): 
    return producto(suma(a, a), suma(b, b))//100 

def main_pll(a, b): 
    return a_calc_pll.map(a, b) 

def main_lb(a, b): 
    c = lbview.map(a_calc_remote, a, b, block=True) 
    return c 

def main(a, b): 
    c = [] 
    for i in range(len(a)): 
     c += [a_calc(a[i], b[i]).tolist()] 
    return c 

if __name__ == '__main__': 
    a, b = [], [] 

    for i in range(1, 1000): 
     a.append(np.array(range(i+00, i+10))) 
     b.append(np.array(range(i+10, i+20))) 

    t = time.time() 
    c1 = main_pll(a, b) 
    t1 = time.time()-t 

    t = time.time() 
    c2 = main(a, b) 
    t2 = time.time()-t 

    t = time.time() 
    c3 = main_lb(a, b) 
    t3 = time.time()-t  

    print(str(c1) == str(c2)) 
    print(str(c3) == str(c2)) 
    print('%f secs (multicore)' % t1) 
    print('%f secs (singlecore)' % t2) 
    print('%f secs (multicore_load_balance)' % t3) 

을

내 검색 결과 :

True 
True 
0.040741 secs (multicore) 
0.004004 secs (singlecore) 
1.286592 secs (multicore_load_balance) 

왜 멀티 코어 루틴이 단일 코어 루틴보다 느립니까? 이 접근 방식의 문제점은 무엇입니까? 문제를 해결하려면 어떻게해야합니까?

일부 정보 : 2.2.0 ipython python3.4.1, NumPy와 1.9.0은 LocalEngineSetLauncher

Answer 1

8 개 엔진을 시작 ipcluster 당신이 실행 너무 적은 시간이 걸립니다 뭔가를 parallelise하려고하는 나에게 보인다 단일 코어. 파이썬에서 "진정한"병렬 처리는 멀티 프로세스입니다. 즉, 여러 개의 파이썬 인터프리터를 생성하고 산세/unpickling 등을 통해 데이터를 전송해야합니다.

작은 작업 부하. 내가 사용하는 장식이 장면 뒤에 무엇을하고 있는지 잘 모르겠지만, 당신이 볼 수있는

# time python -c "pass" 

real 0m0.018s 
user 0m0.012s 
sys  0m0.005s 

: 내 시스템, 단지 시작 후 즉시 파이썬 인터프리터 중지에 약 1/100 초 소요 병렬 작업을위한 인프라를 설정하는 것만으로도 상당한 시간이 걸릴 수 있습니다. 오버 헤드가 그림 밖으로 수 있습니다 위의 암시, 그래서 당신은 이미 당신의 코드를 실행하기 전에 노동자를 설정처럼

편집 추가 검사에

, 그것은 보인다.

작업자 프로세스로 1000 개의 NumPy 배열로 구성된 두 개의 목록을 이동하는 중입니다. 내 시스템의 문자열에 a 및 b을 절인하면 pickle ~ 0.13 초, cPickle으로 ~ 0.046 초가 걸립니다. 산 세척 시간은 대신 목록, NumPy와 배열의, 당신의 배열을 저장하여 감소시킬 수있다 :이 cPickle 시간 ~ 0.029 초를 줄인다

a = np.array(a) 
b = np.array(b) 

. 이 방법을 사용하여 '