Время расчета на нескольких процессорах в 30-40 раз больше чем на одном

# -*- coding: utf-8 -*-
import time
import ctypes
import multiprocessing as mp
import numpy as np
import math
 
def getL(p1, p2):
    u""" Расстояние между 2-мя точками
    """
    return math.sqrt((p1[0]-p2[0])**2+(p1[1]-p2[1])**2)
 
def generateField(w, h):
    u""" Генерируем массив
    """
    field = []
    for x in xrange(w):
        field.append([])
        for y in xrange(h):
            field[x].append(0)
    return field
 
def spCalcFn(field, p):
    u""" Расчет на одном процессоре
    """
    xP = p[0]
    yP = p[1]
    w = len(field)
    h = len(field[0])
    ## для каждой точки определяем расстояние до расчетной точки p
    for x in xrange(w):
        for y in xrange(h):
            field[x][y] = getL(p, (x,y))
    return field
 
def mpCalcFn_Worker(field, queue, memory, p):
    u""" Worker process для расчета на нескольких процессорах
    """
    xP = p[0]
    yP = p[1]
    
    w = len(field)      # ширина 
    h = len(field[0])   # высота
 
    ## область общей памяти
    fieldResult = np.reshape(np.frombuffer(memory), (w, h))
 
    while True:
        ## получаем задание (начальная строка, кол-во строк)
        job = queue.get()
        if job == None:
            break
 
        ## начальная строка
        start = job[0]
        ## конечная строка
        stop = job[0] + job[1]
        
        ## для каждой точки в строках от start до stop 
        ## определяем расстояние до расчетной точки p
        for x in xrange(start, stop):
            for y in xrange(h):
                fieldResult[x][y] = getL(p, (x,y))
        queue.task_done()
    queue.task_done()
 
def mpCalcFn(field, p):
    u""" Расчет на нескольких процессорах
    """
 
    w = len(field)      # ширина 
    h = len(field[0])   # высота
    
    ## создаем область общей памяти 
    memory = mp.RawArray(ctypes.c_double, w * h)
   
    # setup jobs
#    nCPU = mp.cpu_count()    # количество процессоров
    nCPU = 4
    nJobs = nCPU
   
    q = w / nJobs  
    r = w % nJobs  
 
    jobs = []   
    firstRow = 0 
    for i in range(nJobs): 
        rowsInJob = q ## количество обрабатываем строк в одном job
        if (r > 0): # если остаток от деления больше 0
            # увеличиваем количество строк на 1
            rowsInJob += 1
            # уменьшаем остаток на 1
            r -= 1
        ## добавляем в перечень работ сведения о первой строке и количестве строк
        jobs.append((firstRow, rowsInJob)) 
        firstRow += rowsInJob 
    
    ## создаем очередь    
    queue = mp.JoinableQueue()
    ## добавляем jobs в очередь
    for job in jobs:
        queue.put(job)
    ## добавляем в конец очереди None по количеству процессоров
    for i in range(nCPU):
        queue.put(None)
 
    # run workers
    workers = []
    for i in range(nCPU):
        ## создаем процесс 
        worker = mp.Process(target = mpCalcFn_Worker,
                            args = (field, queue, memory, p))
        #№ добавляем
        workers.append(worker)
        ## запускае процесс на выполнение
        worker.start()
        
    queue.join()
   
    ## из области общей памяти создаем массив с результатами 
    fieldResult = np.reshape(np.frombuffer(memory), (w, h))
    return fieldResult
 
def main():
    u""" Сравниваем время выполнения на одном и на нескольких процессорах
    """
    ## количество процессоров
    print u"Количество процессоров: %.0f" % mp.cpu_count()
    
    ## генерируем двумерный массив
    field = generateField(2000, 800)
    ## выбираем точку для расчета
    p = (100, 100)
    
    ## расчет на одном процессоре    
    t0 = time.time()
    spField = spCalcFn(field, p)
    t1 = time.time()
    print u"Один процессор: %.3f сек." % (t1 - t0)
 
    ## расчет на нескольких процессорах
    t0 = time.time()
    mpField = mpCalcFn(field, p)
    t1 = time.time()
    print u"Несколько процессоров: %.3f сек." % (t1 - t0)
 
if __name__ == '__main__':
    main()

x, y = np.meshgrid(np.arange(start, stop), np.arange(h))
# p == (p[0], p[1])
fieldResult = np.sqrt(np.power(x - p[0], 2) + np.power(y - p[1], 2))

import numpy as np
 
def point_in_contour(p, x0, y0):
    x1 = np.roll(x0, 1)
    y1 = np.roll(y0, 1)
    in_trap_x = np.logical_or(np.logical_and(x0 <= p[0], p[0] < x1), np.logical_and(x1 <= p[0], p[0] < x0))
    x0_, y0_, x1_, y1_ = [arr[in_trap_x] for arr in x0, y0, x1, y1]
    k = (y1_ - y0_) / (x1_ - x0_)
    ly = y0_ + k * (p[0] - x0_)
    gr = ly > p[1]  # or >=
    if gr.size == 0:
        result = False
    else:
        result = np.logical_xor.reduce(gr)
    return result

x = np.array([1, 0, 1, 3, 4, 3])
y = np.array([0, 2, 4, 4, 2, 0])
    
print point_in_contour((0.5, 1.), x, y)