Интересная проблема. Поскольку я полагал, что можно добиться лучшего масштабирования, я исследовал производительность с помощью небольшого «теста». В этом тесте я сравнил производительность однопоточного и многопоточного eig (многопоточность реализуется через подпрограммы MKL LAPACK/BLAS) с распараллеленным IPython eig. Чтобы увидеть, какая разница, я изменил тип представления, количество движков и MKL-потоков, а также метод распределения матриц по движкам.

Вот результаты на старой двухъядерной системе AMD:

 m_size=300, n_mat=64, repeat=3
+------------------------------------+----------------------+
| settings                           | speedup factor       |
+--------+------+------+-------------+-----------+----------+
| func   | neng | nmkl | view type   | vs single | vs multi |
+--------+------+------+-------------+-----------+----------+
| ip_map |    2 |    1 | direct_view |      1.67 |     1.62 |
| ip_map |    2 |    1 |  loadb_view |      1.60 |     1.55 |
| ip_map |    2 |    2 | direct_view |      1.59 |     1.54 |
| ip_map |    2 |    2 |  loadb_view |      0.94 |     0.91 |
| ip_map |    4 |    1 | direct_view |      1.69 |     1.64 |
| ip_map |    4 |    1 |  loadb_view |      1.61 |     1.57 |
| ip_map |    4 |    2 | direct_view |      1.15 |     1.12 |
| ip_map |    4 |    2 |  loadb_view |      0.88 |     0.85 |
| parfor |    2 |    1 | direct_view |      0.81 |     0.79 |
| parfor |    2 |    1 |  loadb_view |      1.61 |     1.56 |
| parfor |    2 |    2 | direct_view |      0.71 |     0.69 |
| parfor |    2 |    2 |  loadb_view |      0.94 |     0.92 |
| parfor |    4 |    1 | direct_view |      0.41 |     0.40 |
| parfor |    4 |    1 |  loadb_view |      1.62 |     1.58 |
| parfor |    4 |    2 | direct_view |      0.34 |     0.33 |
| parfor |    4 |    2 |  loadb_view |      0.90 |     0.88 |
+--------+------+------+-------------+-----------+----------+

Как вы видите, прирост производительности сильно различается в зависимости от используемых настроек, максимум в 1,64 раза выше, чем у обычного многопоточного eig. В этих результатах функция parfor, которую вы использовали, работает плохо, если на движках не отключена многопоточность MKL (с использованием view.apply_sync(mkl.set_num_threads, 1)).

Изменение размера матрицы также дает заметную разницу. Ускорение использования ip_map на direct_view с 4 двигателями и отключенной многопоточностью MKL по сравнению с обычным многопоточным eig:

 n_mat=32, repeat=3
+--------+----------+
| m_size | vs multi |
+--------+----------+
|     50 |     0.78 |
|    100 |     1.44 |
|    150 |     1.71 |
|    200 |     1.75 |
|    300 |     1.68 |
|    400 |     1.60 |
|    500 |     1.57 |
+--------+----------+

По-видимому, для относительно небольших матриц есть потеря производительности, для промежуточного размера ускорение самое большое, а для больших матриц ускорение снова уменьшается. Я бы мог добиться прироста производительности в 1,75, что, на мой взгляд, сделало бы использование IPython.parallel целесообразным.

Ранее я также провел несколько тестов на двухъядерном ноутбуке Intel, но получил забавные результаты, очевидно, ноутбук перегревался. Но в этой системе ускорение обычно было немного ниже, около 1,5-1,6 макс.

Теперь я думаю, что ответ на ваш вопрос должен быть: это зависит. Прирост производительности зависит от аппаратного обеспечения, библиотеки BLAS/LAPACK, размера задачи и способа развертывания IPython.parallel, среди прочего, возможно, о чем я не знаю. И последнее, но не менее важное: стоит ли оно того, зависит и от того, сколько прироста производительности, вы считаете, стоящим.

Код, который я использовал:

from __future__ import print_function
from numpy.random import rand
from IPython.parallel import Client
from mkl import set_num_threads
from timeit import default_timer as clock
from scipy.linalg import eig
from functools import partial
from itertools import product

eig = partial(eig, right=False)  # desired keyword arg as standard

class Bench(object):
    def __init__(self, m_size, n_mat, repeat=3):
        self.n_mat = n_mat
        self.matrix = rand(n_mat, m_size, m_size)
        self.repeat = repeat
        self.rc = Client()

    def map(self):
        results = map(eig, self.matrix)

    def ip_map(self):
        results = self.view.map_sync(eig, self.matrix)

    def parfor(self):
        results = {}
        for i in range(self.n_mat):
            results[i] = self.view.apply_async(eig, self.matrix[i,:,:])
        for i in range(self.n_mat):
            results[i] = results[i].get()

    def timer(self, func):
        t = clock()
        func()
        return clock() - t

    def run(self, func, n_engines, n_mkl, view_method):
        self.view = view_method(range(n_engines))
        self.view.apply_sync(set_num_threads, n_mkl)
        set_num_threads(n_mkl)
        return min(self.timer(func) for _ in range(self.repeat))

    def run_all(self):
        funcs = self.ip_map, self.parfor
        n_engines = 2, 4
        n_mkls = 1, 2
        views = self.rc.direct_view, self.rc.load_balanced_view
        times = []
        for n_mkl in n_mkls:
            args = self.map, 0, n_mkl, views[0]
            times.append(self.run(*args))
        for args in product(funcs, n_engines, n_mkls, views):
            times.append(self.run(*args))
        return times

Не знаю, имеет ли это значение, но чтобы запустить 4 параллельных движка IPython, я набрал в командной строке:

ipcluster start -n 4

Надеюсь это поможет :)