Выполните функцию асинхронно на параллельном рабочем пула
запрашивает асинхронное выполнение функционального F
= parfeval(p
,fcn
,numout
,in1,in2,...
)fcn
на рабочем, содержавшемся в параллельном пуле p
, ожидание numout
выходные аргументы и предоставляющий как входные параметры in1,in2,...
. Асинхронная оценка fcn
не делает блока MATLAB. F
parallel.FevalFuture
объект, из которого могут быть получены результаты, когда рабочий завершил оценку fcn
. Оценка fcn
всегда доходы, если вы явным образом не отменяете выполнение путем вызова cancel(F)
. Чтобы запросить несколько вычислений функции, необходимо вызвать parfeval
многократно. (Однако parfevalOnAll
может запустить ту же функцию на всех рабочих.)
запрашивает асинхронное выполнение на текущем параллельном пуле. Если никакой пул не существует, это запускает новый параллельный пул, если ваши параллельные настройки не отключают автоматическое создание пулов.F
= parfeval(fcn
,numout
,in1,in2,...
)
parfeval
ФьючерсыКогда вы используете parfeval
или parfevalOnAll
чтобы запустить расчеты в фоновом режиме, вы создаете названные фьючерсы объектов. Можно использовать State
свойство будущего узнать, запускается ли это, поставленный в очередь или законченный. Можно также использовать FevalQueue
свойство параллельного пула к выполнению доступа и поставленным в очередь фьючерсам. Чтобы отменить фьючерсы, можно использовать cancel
функция. В этом примере, вас:
Используйте cancel
отменять фьючерсы непосредственно.
Проверяйте ошибки завершения на завершенных фьючерсах.
Используйте FevalQueue
свойство получить доступ к фьючерсам.
Добавьте работу в очередь
Создайте параллельный пул p
с двумя рабочими.
p = parpool(2);
Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: 2).
Когда вы используете parfeval
чтобы запустить расчеты в фоновом режиме, функция создает и добавляет будущее для каждого расчета очереди пула. Задачи остаются в очереди, пока рабочий не становится неактивным. Когда рабочий становится неактивным, это начинает вычислять задачу, если очередь не пуста. Когда рабочий выполняет задачу, задача удалена из очереди, и рабочий становится неактивным.
Используйте parfeval
создать массив фьючерсов f
давая рабочим команду выполнить функциональный pause
. Используйте аргумент 1
для третьего будущего и аргумента Inf
для всех других фьючерсов.
for n = 1:5 if n == 3 f(n) = parfeval(@pause,0,1); else f(n) = parfeval(@pause,0,Inf); end end
Каждое использование parfeval
возвращает будущий объект, который представляет выполнение функции на рабочем. За исключением третьего будущего, каждое будущее займет бесконечное количество времени, чтобы вычислить. Будущее создается parfeval(@pause,0,Inf)
крайний случай будущего, которое может замедлить очередь.
Отмените фьючерсы непосредственно
Можно использовать State
свойство получить состояние фьючерсов. Создайте массив ячеек состояния каждого будущего в f
.
{f.State}
ans = 1×5 cell
{'running'} {'running'} {'queued'} {'queued'} {'queued'}
Каждая задача за исключением трети делает паузу навсегда.
Отмените второе будущее непосредственно с cancel
.
cancel(f(2)); {f.State}
ans = 1×5 cell
{'running'} {'finished'} {'running'} {'queued'} {'queued'}
После того, как вы отменяете второе будущее, третьи будущие запуски. Ожидайте, пока третье будущее не завершается, затем исследуйте состояния снова.
wait(f(3)); {f.State}
ans = 1×5 cell
{'running'} {'finished'} {'finished'} {'running'} {'queued'}
Третье будущее теперь имеет 'finished'
состояния.
Проверяйте ошибки завершения
Когда будущее завершается, его State
свойство становится 'finished'
. Чтобы различать фьючерсы, которые отменяются и обычно завершаются, используйте Error
свойство.
fprintf("f(2): %s\n", f(2).Error.message)
f(2): Execution of the future was cancelled.
fprintf("f(3): %s\n", f(3).Error.message)
f(3):
Код отменяет второе будущее, как свойство сообщения указывает. Второе будущее было отменено, как утверждено в message
свойство. Третье будущее завершается без ошибки, и поэтому не имеет сообщения об ошибке.
Отмените фьючерсы в очереди пула
Можно использовать FevalQueue
свойство получить доступ к фьючерсам в очереди пула.
p.FevalQueue
ans = FevalQueue with properties: Number Queued: 1 Number Running: 2
У очереди есть два свойства: RunningFutures
и QueuedFutures
. RunningFutures
свойство является массивом фьючерсов, соответствуя задачам, которые в настоящее время запускаются.
disp(p.FevalQueue.RunningFutures)
1x2 FevalFuture array: ID State FinishDateTime Function Error -------------------------------------------------------- 1 12 running @pause 2 15 running @pause
QueuedFutures
свойство является массивом фьючерсов, соответствуя задачам, которые в настоящее время ставятся в очередь и не выполнение.
disp(p.FevalQueue.QueuedFutures)
FevalFuture with properties: ID: 16 Function: @pause CreateDateTime: 15-Jul-2020 17:29:37 StartDateTime: Running Duration: 0 days 0h 0m 0s State: queued Error: none
Можно отменить одно будущее или массив фьючерсов. Отмените все фьючерсы в QueuedFutures
.
cancel(p.FevalQueue.QueuedFutures); {f.State}
ans = 1×5 cell
{'running'} {'finished'} {'finished'} {'running'} {'finished'}
RunningFutures
и QueuedFutures
сортируются от самых старых до новейших, независимо от ли f
в порядке от самых старых до новейших. Каждое будущее имеет уникальный ID
свойство в течение времени жизни клиента. Проверяйте ID
свойство каждых из фьючерсов в f
.
disp(f)
1x5 FevalFuture array: ID State FinishDateTime Function Error -------------------------------------------------------------- 1 12 running @pause 2 13 finished (unread) 15-Jul-2020 17:29:37 @pause Error 3 14 finished (unread) 15-Jul-2020 17:29:39 @pause 4 15 running @pause 5 16 finished (unread) 15-Jul-2020 17:29:39 @pause Error
Сравните результат с ID
свойство каждого RunningFutures
.
for j = 1:length(p.FevalQueue.RunningFutures) rf = p.FevalQueue.RunningFutures(j); fprintf("p.FevalQueue.RunningFutures(%i): ID = %i\n", j, rf.ID) end
p.FevalQueue.RunningFutures(1): ID = 12 p.FevalQueue.RunningFutures(2): ID = 15
Здесь, RunningFutures
массив, содержащий f(1)
и f(4)
. Если вы отменяете RunningFutures(2)
, вы отменяете четвертый будущий f(4)
.
Иногда, фьючерсы не доступны в рабочей области, например, если вы выполняете ту же часть кода дважды, прежде чем это закончится, или если вы используете parfeval
в функции. Можно отменить фьючерсы, которые не доступны в рабочей области.
Очистите f
из рабочей области.
clear f
Можно использовать RunningFutures
и QueuedFutures
к фьючерсам доступа, которые еще не завершились. Используйте RunningFutures
отменять f(4)
.
rf2 = p.FevalQueue.RunningFutures(2); cancel(rf2) rf2.State
ans = 'finished'
Чтобы отменить все фьючерсы все еще в очереди, используйте следующий код.
cancel([p.FevalQueue.RunningFutures p.FevalQueue.QueuedFutures])
Использование parfeval
запрашивать асинхронное выполнение функции на рабочем.
Например, отправьте один запрос к параллельному пулу. Получите выходные параметры при помощи fetchOutputs
.
f = parfeval(@magic,1,10); value = fetchOutputs(f);
Можно также представить вектор из нескольких будущих запросов в a for
- цикл и собирает результаты, когда они становятся доступными. Для КПД предварительно выделите массив будущих объектов прежде.
f(1:10) = parallel.FevalFuture; for idx = 1:10 f(idx) = parfeval(@magic,1,idx); end
Получите отдельные будущие выходные параметры, когда они становятся доступными при помощи fetchNext
.
magicResults = cell(1,10); for idx = 1:10 [completedIdx,value] = fetchNext(f); magicResults{completedIdx} = value; fprintf('Got result with index: %d.\n', completedIdx); end
parfeval
В этом примере показано, как выполнить параллельную развертку параметра с parfeval
и передайте результаты обратно во время расчетов с DataQueue
объект. parfeval
не делает блока MATLAB, таким образом, можно продолжить работать, в то время как расчеты происходят.
Пример выполняет развертку параметра в системе Лоренца обыкновенных дифференциальных уравнений на параметрах и , и показывает хаотическую природу этой системы.
Создайте сетку параметра
Задайте область значений параметров, которые вы хотите исследовать в развертке параметра.
gridSize = 40; sigma = linspace(5, 45, gridSize); rho = linspace(50, 100, gridSize); beta = 8/3;
Создайте 2D сетку параметров при помощи meshgrid
функция.
[rho,sigma] = meshgrid(rho,sigma);
Создайте объект фигуры и установите 'Visible'
к true
так, чтобы это открылось в новом окне, за пределами live скрипта. Чтобы визуализировать результаты развертки параметра, создайте объемную поверхностную диаграмму. Обратите внимание на то, что инициализация Z
компонент поверхности с NaN
создает пустой график.
figure('Visible',true); surface = surf(rho,sigma,NaN(size(sigma))); xlabel('\rho','Interpreter','Tex') ylabel('\sigma','Interpreter','Tex')
Настройте параллельную среду
Создайте пул параллельных рабочих при помощи parpool
функция.
parpool;
Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: 6).
Чтобы отправить данные от рабочих, создайте DataQueue
объект. Настройте функцию, которая обновляет объемную поверхностную диаграмму каждый раз, когда рабочий отправляет данные при помощи afterEach
функция. updatePlot
функция является функцией, определяемой поддержки в конце примера.
Q = parallel.pool.DataQueue; afterEach(Q,@(data) updatePlot(surface,data));
Выполните параллельную развертку параметра
После того, как вы зададите параметры, можно выполнить параллельную развертку параметра.
parfeval
работает более эффективно, когда вы распределяете рабочую нагрузку. Чтобы распределить рабочую нагрузку, сгруппируйте параметры, чтобы исследовать в разделы. В данном примере разделите в универсальные разделы размера step
при помощи оператора двоеточия (:
). Полученный массив partitions
содержит контуры разделов. Обратите внимание на то, что необходимо добавить конечную точку последнего раздела.
step = 100; partitions = [1:step:numel(sigma), numel(sigma)+1]
partitions = 1×17
1 101 201 301 401 501 601 701 801 901 1001 1101 1201 1301 1401 1501 1601
Для лучшей эффективности попытайтесь разделить в разделы, которые являются:
Достаточно большой, что время вычисления является большим по сравнению с издержками планирования раздела.
Достаточно маленький, что существует достаточно разделов, чтобы заставить всех рабочих напряженно трудиться.
Чтобы представлять функциональное выполнение на параллельных рабочих и содержать их результаты, используйте будущие объекты.
f(1:numel(partitions)-1) = parallel.FevalFuture;
Разгрузите расчеты, чтобы быть параллельными рабочим при помощи parfeval
функция. parameterSweep
функция, определяемая помощника в конце этого скрипта, который решает систему Лоренца на разделе параметров, чтобы исследовать. Это имеет один выходной аргумент, таким образом, необходимо задать 1
как количество выходных параметров в parfeval
.
for ii = 1:numel(partitions)-1 f(ii) = parfeval(@parameterSweep,1,partitions(ii),partitions(ii+1),sigma,rho,beta,Q); end
parfeval
не делает блока MATLAB, таким образом, можно продолжить работать, в то время как расчеты происходят. Рабочие вычисляют параллельно и отправляют промежуточные результаты через DataQueue
как только они становятся доступными.
Если вы хотите с блоком MATLAB до parfeval
завершается, используйте wait
функция на будущих объектах. Используя wait
функция полезна, когда последующий код зависит от завершения parfeval
.
wait(f);
После parfeval
закончил расчеты, wait
концы и вы можете выполнить больше кода. Например, постройте контур получившейся поверхности. Используйте fetchOutputs
функция, чтобы получить результаты, сохраненные в будущих объектах.
results = reshape(fetchOutputs(f),gridSize,[]); contourf(rho,sigma,results) xlabel('\rho','Interpreter','Tex') ylabel('\sigma','Interpreter','Tex')
Если вашей развертке параметра нужно больше вычислительных ресурсов, и у вас есть доступ к кластеру, можно увеличить parfeval
расчеты. Для получения дополнительной информации смотрите, Масштабируют от Рабочего стола до Кластера.
Определение функций помощника
Задайте функцию помощника, которая решает систему Лоренца на разделе параметров, чтобы исследовать. Отправьте промежуточные результаты клиенту MATLAB при помощи send
функция на DataQueue
объект.
function results = parameterSweep(first,last,sigma,rho,beta,Q) results = zeros(last-first,1); for ii = first:last-1 lorenzSystem = @(t,a) [sigma(ii)*(a(2) - a(1)); a(1)*(rho(ii) - a(3)) - a(2); a(1)*a(2) - beta*a(3)]; [t,a] = ode45(lorenzSystem,[0 100],[1 1 1]); result = a(end,3); send(Q,[ii,result]); results(ii-first+1) = result; end end
Задайте другую функцию помощника, которая обновляет объемную поверхностную диаграмму, когда новые данные прибывают.
function updatePlot(surface,data) surface.ZData(data(1)) = data(2); drawnow('limitrate'); end
afterEach
и afterAll
В этом примере показано, как обновить пользовательский интерфейс, когда расчеты завершаются. Когда вы разгружаете расчеты рабочим, использующим parfeval
, все пользовательские интерфейсы являются быстро реагирующими, в то время как рабочие выполняют эти расчеты. В этом примере вы используете waitbar
создать простой пользовательский интерфейс.
Используйте afterEach
чтобы обновить пользовательский интерфейс после, каждый расчет завершается.
Используйте afterAll
обновить пользовательский интерфейс после всех завершенных расчетов.
Используйте waitbar
создать указатель фигуры, h
. Когда вы используете afterEach
или afterAll
, waitbar
функционируйте обновляет указатель фигуры. Для получения дополнительной информации об объектах указателя, смотрите Поведение объекта Указателя.
h = waitbar(0,'Waiting...');
Используйте parfeval
вычислить действительную часть собственных значений случайных матриц. С настройками по умолчанию, parfeval
автоматически создает параллельный пул, если вы уже не создаетесь.
for idx = 1:100 f(idx) = parfeval(@(n) real(eig(randn(n))),1,5e2); end
Можно использовать afterEach
автоматически вызвать функции на каждый из результатов parfeval
расчеты. Используйте afterEach
чтобы вычислить самое большое значение в каждом из выходных массивов после, каждое будущее завершается.
maxFuture = afterEach(f,@max,1);
Можно использовать State
свойство получить состояние фьючерсов. Создайте логический массив где State
свойство фьючерсов в f
"finished"
. Используйте mean
вычислить часть законченных фьючерсов. Затем создайте анонимную функцию updateWaitbar
. Функция изменяет дробную длину панели ожидания h
к части законченных фьючерсов.
updateWaitbar = @(~) waitbar(mean({f.State} == "finished"),h);
Используйте afterEach
и updateWaitbar
обновить дробную длину панели ожидания после каждого будущего в maxFuture
завершается. Используйте afterAll
и delete
чтобы закрыть панель ожидания после, все расчеты завершены.
updateWaitbarFutures = afterEach(f,updateWaitbar,0); afterAll(updateWaitbarFutures,@(~) delete(h),0);
Используйте afterAll
и histogram
показать гистограмму результатов в maxFuture
после всех завершенных фьючерсов.
showsHistogramFuture = afterAll(maxFuture,@histogram,0);
p
— Параллельный пулparallel.Pool
объектПараллельный пул рабочих в виде parallel.Pool
объект. Можно создать параллельный пул при помощи parpool
функция.
Типы данных: parallel.Pool
fcn
— Функция, чтобы выполнитьсяФункция, чтобы выполниться на рабочем в виде указателя на функцию.
Пример: fcn = @sum
Типы данных: function_handle
numout
— Количество выходных аргументовКоличество выходных аргументов, которые ожидаются от fcn
.
Типы данных: single
| double
| int8
| int16
| int32
| int64
| uint8
| uint16
| uint32
| uint64
in1,in2,...
Аргументы функцииАргументы функции, чтобы передать fcn
В виде списка, разделенного запятыми переменных или выражений.
F
— Будущееparallel.FevalFuture
Будущий объект, возвращенный как parallel.FevalFuture
, это представляет выполнение fcn
на параллельном рабочем и содержит его результаты. Использование fetchOutputs
или fetchNext
собрать результаты.
afterAll
| afterEach
| cancel
| fetchNext
| fetchOutputs
| Future
| isequal
| parallel.pool.Constant
| parfevalOnAll
| parpool
| ticBytes
| tocBytes
| wait
У вас есть модифицированная версия этого примера. Вы хотите открыть этот пример со своими редактированиями?
1. Если смысл перевода понятен, то лучше оставьте как есть и не придирайтесь к словам, синонимам и тому подобному. О вкусах не спорим.
2. Не дополняйте перевод комментариями “от себя”. В исправлении не должно появляться дополнительных смыслов и комментариев, отсутствующих в оригинале. Такие правки не получится интегрировать в алгоритме автоматического перевода.
3. Сохраняйте структуру оригинального текста - например, не разбивайте одно предложение на два.
4. Не имеет смысла однотипное исправление перевода какого-то термина во всех предложениях. Исправляйте только в одном месте. Когда Вашу правку одобрят, это исправление будет алгоритмически распространено и на другие части документации.
5. По иным вопросам, например если надо исправить заблокированное для перевода слово, обратитесь к редакторам через форму технической поддержки.