Das deutsche Python-Forum

Code: Alles auswählen

from multiprocessing import Pool

def f(x):
    return x*x*x

if __name__ == '__main__':
    p = Pool(5)
    x=p.map(f,[1,2,3,4])
    print(p.map(f, [1, 2, 3]))
    print(x)

Code: Alles auswählen

from multiprocessing import Pool

def  f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=4)              # start 4 worker processes
    result = pool.apply_async(f, [10])    # evaluate "f(10)" asynchronously
    print(result.get(timeout=1))           # prints "100" unless your computer is *very* slow
    print(pool.map(f, range(10)))          # prints "[0, 1, 4,..., 81]"

Code: Alles auswählen

p = Pool(5)
pool = Pool(processes=4) 

Code: Alles auswählen

def decompress(payload,WIDTH,HEIGHT):
    # INPUTS / OUTPUTS
    n_threads = 4                                                                           
    img_input = np.fromstring(payload, dtype='uint32')                                      
    img_output = np.zeros((WIDTH * HEIGHT), dtype=np.uint32)                            
    n_elements_part = np.int(len(img_input) / n_threads)                                    
    input_part=np.zeros((n_threads,n_elements_part)).astype(np.uint32)                      
    output_part =np.zeros((n_threads,np.int(n_elements_part/3*8))).astype(np.uint32)        

    # DEFINE PARTS (here 4 different ones)
    start = np.zeros(n_threads).astype(np.int)                          
    end = np.zeros(n_threads).astype(np.int)                            
    for i in range(0,n_threads):
        start[i] = i * n_elements_part
        end[i] = (i+1) * n_elements_part -1

    # COPY IMAGE DATA
    for idx in range(0,n_threads):
        input_part [idx,:] = img_input[start[idx]:end[idx]+1]


    for idx in range(0,n_threads):                          # following line is the function_call that should be parallized
        output_part[idx,:] = decompress_part2(input_part[idx],output_part[idx])



    # COPY PARTS INTO THE IMAGE
    img_output[0     : 188160] = output_part[0,:]
    img_output[188160: 376320] = output_part[1,:]
    img_output[376320: 564480] = output_part[2,:]
    img_output[564480: 752640] = output_part[3,:]

    # RESHAPE IMAGE
    img_output = np.reshape(img_output,(HEIGHT, WIDTH))

    return img_output

Code: Alles auswählen

import multiprocessing
import numpy as np

def split(data,parts,step, length):
	data_array=np.zeros((parts,step))

	for i in range(parts):	
		data_array[i,:] = data[i*step:(i+1)*step]

	return(data_array)

def mul(arr, scalar):
	result = np.multiply(arr,scalar)
	return(result)

data = np.linspace(1.0, 100.0, num=24).astype(int)
parts = 4
length=len(data)
step = np.int(length/parts)
scalar = 2
data_array = split(data,parts,step,length)						
res_array = np.zeros((parts,step))
print(data_array)

for idx in range(parts):
	test = data_array[idx,:]
	res_array[idx,:] = mul(test,scalar)	# Line to be parallized !

#with multiprocessing.Pool(parts) as p:
	#results = (p.map(mul(data_arr,2),parts))

print('\n',res_array)

Code: Alles auswählen

import multiprocessing
import numpy as np

scalar = 2
data = np.linspace(1.0, 100.0, num=24).astype(int)
parts = 4

def calc(part):
    return part * scalar

result = np.zeros_like(data)
for idx, part in enumerate(data.reshape(parts, -1)):
   result[idx,:] = calc(part)

print(result)

with multiprocessing.Pool(parts) as p:
    results = p.map(calc, data.reshape(parts, -1))

print(results)

Code: Alles auswählen

result = []
for part in data.reshape(parts, -1):
   result.append(calc(part))