LXF165-166:Язы­ки про­грам­ми­ро­вания: Erlang 92

Подписка на печатную версию Весь 2015 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Подписка на электронную версию Весь 2015 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Подшивки старых номеров журнала (печатные версии) Весь 2014 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Erlang Опи­сы­ва­ет­ся сле­дую­щей фор­му­лой: функ­цио­наль­ный язык + про­цес­сы

Erlang: И сно­ва прак­ти­кум

Ан­д­рей Уша­ков счи­та­ет, что од­но­го прак­ти­ку­ма по мно­го­за­дач­но­сти ма­ло­ва­то – и про­во­дит вто­рой.

Наш эксперт Ан­д­рей Уша­ков ак­тив­но при­бли­жа­ет тот день, ко­гда функ­цио­наль­ные язы­ки ста­нут мейн­ст­ри­мом.

В про­шлый раз в нашем прак­ти­куме по мно­го­за­дач­но­сти мы ре­ши­ли соз­дать мно­го­за­дач­ные вер­сий та­ких по­пу­ляр­ных в про­грам­ми­ро­вании функ­ций, как map (опе­ра­ция ото­бра­жения) и reduce (опе­ра­ция сверт­ки). Эти функ­ции бы­ли вы­бра­ны не слу­чай­но: их обыч­ные, не мно­го­за­дач­ные реа­ли­за­ции на­столь­ко про­сты, что при соз­дании их мно­го­за­дач­ных вер­сий незачем силь­но от­вле­кать­ся на де­та­ли, не свя­зан­ные с мно­го­за­дач­но­стью. Про­сто­ту их мы по­ка­за­ли в про­шлый раз, соз­дав их обыч­ную (не мно­го­за­дач­ную) реа­ли­за­цию. Так­же мы соз­да­ли про­стую мно­го­за­дач­ную вер­сию функ­ции map, ис­поль­зующую для ото­бра­жения ка­ж­до­го эле­мен­та свой ра­бо­чий про­цесс. При та­ком под­хо­де (по про­цессу на эле­мен­т) соз­дание мно­го­за­дач­ной вер­сии функ­ции reduce не име­ет смыс­ла. Для соз­дания мно­го­за­дач­ной вер­сии функ­ции reduce (и бо­лее гиб­кой мно­го­за­дач­ной вер­сии функ­ции map) надо раз­би­вать дан­ные на пор­ции и эти пор­ции об­ра­ба­ты­вать па­рал­лель­но, по­сле че­го фор­ми­ро­вать ито­го­вый ре­зуль­тат. На этом мы и оста­но­ви­лись в про­шлый раз.

Снова рас­смот­рим вспо­мо­га­тель­ные функ­ции, соз­да­нные в про­шлый раз для ра­бо­ты с пор­ция­ми дан­ных. Эти функ­ции им­пор­ти­ру­ют­ся из мо­ду­ля parallel_common. Функ­ция calc_portion_count/2 по­зво­ля­ет вы­чис­лить ко­ли­че­­ст­во пор­ций дан­ных по за­дан­ным раз­ме­рам пор­ции и ис­ход­но­го спи­ска с дан­ны­ми:

calc_portion_count(TotalSize, PortionSize)

when TotalSize rem PortionSize == 0 -> TotalSize div PortionSize;

calc_portion_count(TotalSize, PortionSize)

when TotalSize rem PortionSize /= 0 -> (TotalSize div PortionSize) + 1.

Па­ра функ­ций prepare_data/2 (ин­тер­фейс­ная функ­ция) и prepare_data/3 (функ­ция, реа­ли­зую­щая дан­ную функ­цио­наль­ность) раз­би­ва­ют ис­ход­ные дан­ные на пор­ции:

prepare_data(_PortionSize, []) -> [];

prepare_data(PortionSize, SourceList) -> prepare_data(0, PortionSize, SourceList, []).

prepare_data(Index, PortionSize, SourceList, PreparedData)

when length(SourceList) =< PortionSize ->

lists:reverse([{Index, SourceList}] ++ PreparedData);

prepare_data(Index, PortionSize, SourceList, PreparedData) ->

{Portion, Rest} = lists:split(PortionSize, SourceList),

prepare_data(Index + 1, PortionSize, Rest, [{Index, Portion}] ++ PreparedData).

Ис­ход­ный спи­сок раз­би­ва­ется на спи­сок пар (кор­те­жей), со­стоя­щих из ин­дек­са пор­ции и соб­ст­вен­но са­мой пор­ции с дан­ны­ми.

Те­перь мы го­то­вы дви­гать­ся даль­ше. В мно­го­за­дач­ной вер­сии функ­ции reduce у нас бу­дет один глав­ный про­цесс и несколь­ко вспо­мо­га­тель­ных ра­бо­чих про­цес­сов. Глав­ный про­цесс (в ко­то­ром мы иниции­ру­ем вы­полнение на­шей вер­сии функ­ции reduce) от­вечает за раз­биение дан­ных на пор­ции, соз­дание необ­хо­ди­мо­го ко­ли­че­­ст­ва ра­бо­чих про­цес­сов и за­даний для них, сбор ре­зуль­та­тов ра­бо­ты от всех ра­бо­чих про­цес­сов и, на­конец, сверт­ку ре­зуль­та­тов ра­бо­ты вспо­мо­га­тель­ных про­цес­сов в ито­го­вый ре­зуль­тат. Как и при реа­ли­за­ции функ­ции parallel_map: simple_pmap/2, мы ис­поль­зу­ем «од­но­ра­зо­вые» ра­бо­чие про­цес­сы. При та­ком под­хо­де мо­жно раз­дать за­дания сра­зу же при соз­дании про­цес­сов. А ра­бо­чая функ­ция «од­но­ра­зо­вых» про­цес­сов крайне про­ста: вы­чис­лить ре­зуль­тат сверт­ки для пор­ции и ото­слать его глав­но­му про­цес­су. По­сле соз­дания всех «од­но­ра­зо­вых» ра­бо­чих про­цес­сов все взаи­мо­дей­ст­вие с ними сво­дит­ся толь­ко к по­лу­чению от них ре­зуль­та­тов и со­хранению этих ре­зуль­та­тов в про­ме­жу­точ­ном бу­фе­ре (в мас­си­ве). Для этого мы мо­жем ис­поль­зо­вать функ­цию parallel_common: collect_result/2, толь­ко вме­сто со­хранения от­дель­ных эле­мен­тов по­сле ото­бра­жения (что мы де­ла­ли, когда реа­ли­зо­вы­ва­ли про­стей­ший мно­го­за­дач­ный ва­ри­ант функ­ции map) мы бу­дем со­хра­нять ре­зуль­та­ты сверт­ки для груп­пы эле­мен­тов. Под­ве­дя итог вы­шеска­зан­но­му, мы мо­жем на­пи­сать ра­бо­чую функ­цию глав­но­го про­цес­са (она же точ­ка вхо­да в мно­го­за­дач­ную вер­сию функ­ции reduce) сле­дую­щим об­ра­зом:

portion_reduce(_Fun, [], {InitValue, _PortionInitValue}, _PortionSize) -> InitValue;

portion_reduce(Fun, SourceList, {InitValue, _PortionInitValue}, PortionSize)

when length(SourceList) =< PortionSize ->

lists:foldl(Fun, InitValue, SourceList);

portion_reduce(Fun, SourceList, {InitValue, PortionInitValue}, PortionSize) ->

process_flag(trap_exit, true),

MasterPid = self(),

PortionCount = parallel_common:calc_portion_count(length(SourceList), PortionSize),

PreparedData = parallel_common:prepare_data(PortionSize, SourceList),

lists:foreach(fun({Index, Portion}) -> spawn_link(fun() -> portion_worker(Fun, Portion, PortionInitValue, Index, MasterPid) end) end, PreparedData),

EmptyStorage = array:new([{size, PortionCount}, {fixed, true}, {default, none}]),

FullStorage = parallel_common:collect_result(EmptyStorage, PortionCount),

process_flag(trap_exit, false),

lists:foldl(Fun, InitValue, array:to_list(FullStorage)).

Эта функ­ция со­дер­жит три ва­ри­ан­та. Пер­вый об­ра­ба­ты­ва­ет наи­бо­лее три­ви­аль­ный слу­чай, когда ис­ход­ный спи­сок пуст, и мы воз­вра­ща­ем на­чаль­ное зна­чение опе­ра­ции сверт­ки. Вто­рой ва­ри­ант об­ра­ба­ты­ва­ет си­туа­цию, когда ко­ли­че­­ст­во эле­мен­тов в спи­ске не боль­ше раз­мера пор­ции; тогда нет смыс­ла рас­па­рал­ле­ли­вать вы­полнение функ­ции, и опе­ра­ция сверт­ки вы­пол­ня­ет­ся при по­мо­щи функ­ции lists:foldl/3. И, на­конец, по­следний ва­ри­ант об­ра­ба­ты­ва­ет наи­бо­лее об­щий слу­чай, ко­то­рый и яв­ля­ет­ся мно­го­за­дач­ным. При этом не сто­ит за­бы­вать, что при по­мо­щи ра­бо­чих про­цес­сов мы фор­ми­ру­ем толь­ко ре­зуль­та­ты опе­ра­ции сверт­ки по под­груп­пам; фи­наль­ную опе­ра­цию сверт­ки про­ме­жу­точ­ных ре­зуль­та­тов мы вы­пол­ня­ем в кон­це ра­бо­чей функ­ции глав­но­го про­цес­са. И, конеч­но, мы помним, что функ­ция portion_reduce/3 яв­ля­ет­ся экс­пор­ти­руе­мой функ­ци­ей мо­ду­ля parallel_reduce.

Как го­во­ри­лось в пре­ды­ду­щей ста­тье, при реа­ли­за­ции па­рал­лель­но­го ва­ри­ан­та функ­ции reduce нам необ­хо­ди­мо за­да­вать па­ру на­чаль­ных зна­чений, в от­ли­чие от обыч­но­го ва­ри­ан­та функ­ции reduce. Од­но зна­чение из этой па­ры яв­ля­ет­ся на­чаль­ным зна­чением всей опе­ра­ции сверт­ки, дру­гое же яв­ля­ет­ся «ну­лем» опе­ра­ции сверт­ки; оно необ­хо­ди­мо для вы­полнения опе­ра­ции сверт­ки в под­груп­пах. Так, на­при­мер, ес­ли опе­ра­ци­ей сверт­ки яв­ля­ет­ся опе­ра­ция сум­ми­ро­вания чи­сел, то «ну­лем» бу­дет чис­ло 0, а ес­ли опе­ра­ци­ей сверт­ки бу­дет опе­ра­ция кон­ка­те­на­ции строк, «ну­лем» опе­ра­ции бу­дет пустая стро­ка. В об­щем слу­чае, что бу­дет яв­лять­ся «ну­лем», для опе­ра­ции сверт­ки не вы­чис­лить. По­это­му поль­зо­ва­тель на­шей мно­го­за­дач­ной вер­сии функ­ции reduce дол­жен пе­ре­да­вать как на­чаль­ное зна­чение опе­ра­ции сверт­ки, так и «нуль» этой опе­ра­ции. В на­шей реа­ли­за­ции мы ожи­да­ем, что эти два зна­чения бу­дут пе­ре­да­ны в ви­де па­ры (кор­те­жа) {InitValue, PortionInitValue}, где InitValue – на­чаль­ное зна­чение всей опе­ра­ции сверт­ки, PortionInitValue – «нуль» опе­ра­ции сверт­ки.

Те­перь по­смот­рим на то, чем же занима­ют­ся у нас ра­бо­чие про­цес­сы (т. е. на функ­цию, вы­пол­няе­мую ра­бо­чи­ми про­цес­са­ми). Это функ­ция portion_worker/5, оп­ре­де­лен­ная в мо­ду­ле parallel_reduce (но не экс­пор­ти­руе­мая из это­го мо­ду­ля):

portion_worker(Fun, SourcePortion, InitValue, Index, MasterPid)->

AggrValue = lists:foldl(Fun, InitValue, SourcePortion),

MasterPid ! {result, Index, AggrValue}.

Как мы уже го­во­ри­ли ранее, ра­бо­чие про­цес­сы у нас «од­но­ра­зо­вые», т. е. вы­пол­ня­ют свою за­да­чу и за­кан­чи­ва­ют ра­бо­ту. Имен­но по­это­му функ­ция, ко­то­рую вы­пол­ня­ют ра­бо­чие про­цес­сы, на­столь­ко про­ста: в ней мы вы­чис­ля­ем зна­чение опе­ра­ции сверт­ки для груп­пы и по­сы­ла­ем со­об­щение глав­но­му про­цес­су с вы­чис­лен­ным зна­чением. Со­об­щение име­ет вид {result, Index, AggrValue}, где Index – ин­декс ис­ход­ной пор­ции дан­ных, AggrValue – зна­чение опе­ра­ции сверт­ки для ис­ход­ной пор­ции. В ка­че­­ст­ве на­чаль­но­го зна­чения InitValue для опе­ра­ции сверт­ки пор­ции дан­ных мы пе­ре­да­ем «нуль» опе­ра­ции сверт­ки (при соз­дании ра­бо­чих про­цес­сов).

При­шла по­ра про­ве­рить, что на­ша мно­го­за­дач­ная вер­сия функ­ции reduce ра­бо­та­ет пра­виль­но. Для это­го ком­пи­ли­ру­ем со­от­вет­ст­вую­щие мо­ду­ли и за­пуска­ем кон­соль сре­ды вы­полнения язы­ка Erlang. Так как у нас функ­ция parallel_reduce:portion_reduce/4 име­ет три ва­ри­ан­та, все эти три ва­ри­ан­та бы­ло бы непло­хо про­ве­рить. Для на­ча­ла в ка­че­­ст­ве опе­ра­ции сверт­ки возь­мем опе­ра­цию сло­жения чи­сел. Вы­зов parallel_reduce:portion_reduce(fun(Item, Agg) -> Item Ag+g end, [], {3, 0}, 5) вернет нам в ка­че­­ст­ве зна­чения чис­ло 3, т. е. на­чаль­ное зна­чение опе­ра­ции сверт­ки. Вы­зов parallel_reduce:portion_reduce(fun(Item, Agg) -> Item + Agg end, [1, 2, 3], {3, 0}, 5) вернет чис­ло 9. Это сум­ма всех чи­сел из спи­ска [1, 2, 3] с ве­ли­чи­ной 3 в ка­че­­ст­ве на­чаль­но­го зна­чения сум­мы. Так как ко­ли­че­­ст­во эле­мен­тов в спи­ске – 3, а раз­мер пор­ции – 5, то сум­ма всех чи­сел вы­чис­ля­ет­ся при по­мо­щи вто­ро­го ва­ри­ан­та функ­ции parallel_reduce:portion_reduce/4, т. е. не мно­го­за­дач­ным спо­со­бом. Вы­пол­ня­ем вы­зов parallel_reduce:portion_reduce(fun(Item, Agg) -> Item + Agg end, [1, 2, 3, 4, 5, 6], {3, 0}, 2) и по­лу­ча­ем в ре­зуль­та­те зна­чение 24. Лег­ко про­ве­рить, что сум­ма всех чи­сел из спи­ска с на­чаль­ным зна­чением этой сум­мы 3 бу­дет рав­на 24. В этом вы­зо­ве раз­мер пор­ции ра­вен 2, а ко­ли­че­­ст­во эле­мен­тов в спи­ске – 6; так что при вы­зо­ве бу­дут соз­да­ны 3 ра­бо­чих про­цес­са.

• Метамодернизм в позднем творчестве В.Г. Сорокина
• ЛитРПГ - последняя отрыжка постмодерна
• "Ричард III и семиотика"
• 3D-визуализация обложки Ridero создаем обложку книги при работе над самиздатом.
• Архитектура метамодерна - говоря о современном искусстве, невозможно не поговорить об архитектуре. В данной статье будет отмечено несколько интересных принципов, характерных для построек "новой волны", столь притягательных и скандальных.
• Литература
• Метамодерн
• Рокер-Прометей против изначального зла в «Песне про советскую милицию» Вени Дркина, Автор: Нина Ищенко, к.ф.н, член Союза Писателей ЛНР - перепубликация из журнала "Топос".
• Как избавиться от комаров? Лучшие типы ловушек.
• Что делать если роблокс вылетает на windows
• Что делать, если ребенок смотрит порно?
• Почему собака прыгает на людей при встрече?
• Какое масло лить в Задний дифференциал (мост) Visco diff 38434AA050
• О чем может рассказать хвост вашей кошки?
• Верветки
• Отчетность бюджетных учреждений при закупках по Закону № 223-ФЗ
• Срок исковой давности как правильно рассчитать
• Дмитрий Патрушев минсельхоз будет ли преемником Путина
• Кто такой Владислав Поздняков? Что такое "Мужское Государство" и почему его признали экстремистским в России?
• Как правильно выбрать машинное масло в Димитровграде?
• Как стать богатым и знаменитым в России?
• Почему фильм "Пипец" (Kick-Ass) стал популярен по всему миру?
• Как стать мудрецом?
• Как правильно установить FreeBSD
• Как стать таким как Путин?
• Где лучше жить - в Димитровграде или в Ульяновске?
• Почему город Димитровград так называется?
• Что такое метамодерн?
• ВАЖНО! Временное ограничение движения автотранспортных средств в Димитровграде
• Тарифы на электроэнергию для майнеров предложено повысить

Пре­ды­ду­щая опе­ра­ция сверт­ки бы­ла ком­му­та­тив­ной опе­ра­ци­ей; да­вай­те про­ве­рим ра­бо­ту на­шей мно­го­за­дач­ной вер­сии функ­ции reduce в слу­чае, когда опе­ра­ция сверт­ки ком­му­та­тив­ной не яв­ля­ет­ся. В ка­че­­ст­ве та­кой неком­му­та­тив­ной опе­ра­ции сверт­ки возь­мем опе­ра­цию кон­ка­те­на­ции строк. Как и в пре­ды­ду­щем слу­чае, необ­хо­ди­мо про­ве­рить ра­бо­ту всех трех ва­ри­ан­тов функ­ции parallel_reduce:portion_reduce/4. Вы­зов parallel_reduce:portion_reduce(fun(Item, Agg) -> Agg ++ Item end, [], {“++”, “”}, 2) вернет нам в ка­че­­ст­ве зна­чения стро­ку «++», т. е. на­чаль­ное зна­чение опе­ра­ции кон­ка­те­на­ции. Ре­зуль­та­том вы­полнения вы­зо­ва parallel_reduce:portion_reduce(fun(Item, Agg) -> Agg ++ Item end, [“aa”, “bb”], {“++”, “”}, 5) бу­дет стро­ка «++aabb”. Лег­ко про­ве­рить, что кон­ка­те­на­ция всех строк из ис­ход­но­го спи­ска с на­чаль­ным зна­чением «++» даст нам стро­ку «++aabb”. При этом ко­ли­че­­ст­во эле­мен­тов в спи­ске рав­но 2, а раз­мер пор­ции ра­вен 5; это оз­на­ча­ет, что ре­зуль­тат кон­ка­те­на­ции строк мы по­лу­чи­ли при по­мо­щи вто­ро­го ва­ри­ан­та функ­ции parallel_reduce:portion_reduce/4. И, на­конец, ре­зуль­та­том вы­полнения вы­зо­ва parallel_reduce:portion_reduce(fun(Item, Agg) -> Agg ++ Item end, [“aa”, “bb”, “cc”, “dd”, “ee”, “ff”], {“++”, “”}, 2) бу­дет стро­ка «++aabbccddeeff”. Оче­вид­но, что эта стро­ка яв­ля­ет­ся ре­зуль­та­том кон­ка­те­на­ции всех строк из ис­ход­но­го спи­ска, с на­чаль­ным зна­чением «++». Так как раз­мер спи­ска –6 эле­мен­тов, а раз­мер пор­ции дан­ных – 2, то этот вы­зов бу­дет об­ра­бо­тан треть­им ва­ри­ан­том функ­ции parallel_reduce:portion_reduce/4; при этом бу­дет соз­да­но 3 ра­бо­чих по­то­ка.

Те­перь соз­да­дим мно­го­за­дач­ную вер­сию функ­ции map, ра­бо­чие про­цес­сы ко­то­рой бу­дут об­ра­ба­ты­вать не от­дель­ные эле­мен­ты ис­ход­но­го спи­ска, а пор­ции из эле­мен­тов. Как и рань­ше, у нас бу­дет один глав­ный про­цесс и несколь­ко вспо­мо­га­тель­ных ра­бо­чих про­цес­сов. В глав­ном про­цес­се (в ко­то­ром мы иниции­ру­ем вы­полнение на­шей вер­сии функ­ции map) мы бу­дем раз­би­вать дан­ные на пор­ции, соз­да­вать необ­хо­ди­мое ко­ли­че­­ст­во ра­бо­чих про­цес­сов и за­даний для них, со­би­рать ре­зуль­та­ты ра­бо­ты от всех ра­бо­чих про­цес­сов и, на­конец, пре­об­ра­зо­вы­вать со­б­ран­ные про­ме­жу­точ­ные ре­зуль­та­ты в ито­го­вый спи­сок. При этом ра­бо­чие про­цес­сы у нас про­дол­жа­ют быть «од­но­ра­зо­вы­ми», т. е. они вы­пол­ня­ют свою за­да­чу, от­сы­ла­ют ре­зуль­та­ты ра­бо­ты глав­но­му про­цес­су и за­кан­чи­ва­ют свое су­ще­ст­во­вание в этом брен­ном ми­ре. По­это­му мы мо­жем не оста­нав­ли­вать­ся под­роб­но на прин­ци­пах ра­бо­ты, а сра­зу по­смот­реть код со­от­вет­ст­вую­щих ме­то­дов. Ра­бо­чая функ­ция глав­но­го про­цес­са (она же точ­ка вхо­да в мно­го­за­дач­ную вер­сию функ­ции map) portion_pmap/3 оп­ре­де­ле­на в мо­ду­ле parallel_map (и, ес­те­ст­вен­но, объ­яв­ле­на экс­пор­ти­руе­мой функ­ци­ей из это­го мо­ду­ля):

portion_pmap(_Fun, [], _PortionSize) -> [];

portion_pmap(Fun, SourceList, PortionSize)

when length(SourceList) =< PortionSize ->

lists:map(Fun, SourceList);

portion_pmap(Fun, SourceList, PortionSize) ->

process_flag(trap_exit, true),

MasterPid = self(),

PortionCount = parallel_common:calc_portion_count(length(SourceList), PortionSize),

PreparedData = parallel_common:prepare_data(PortionSize, SourceList),

lists:foreach(fun({Index, Portion}) -> spawn_link(fun() -> portion_worker(Fun, Portion, Index, MasterPid) end) end, PreparedData),

EmptyStorage = array:new([{size, PortionCount}, {fixed, true}, {default, none}]),

FullStorage = parallel_common:collect_result(EmptyStorage, PortionCount),

process_flag(trap_exit, false),

lists:append(array:to_list(FullStorage)).

Как и в слу­чае функ­ции parallel_reduce:portion_reduce/4, мы оп­ре­де­ля­ем три ва­ри­ан­та функ­ции. Пер­вый об­ра­ба­ты­ва­ет слу­чай пусто­го спи­ска; вто­рой – слу­чай, когда ко­ли­че­­ст­во эле­мен­тов в спи­ске мень­ше раз­ме­ра пор­ции (в этом слу­чае нет смыс­ла рас­па­рал­ле­ли­вать за­да­чу); и, на­конец, тре­тий – об­щий слу­чай.

Рас­смот­рим функ­цию, ко­то­рую бу­дут вы­пол­нять ра­бо­чие про­цес­сы. Это функ­ция portion_worker/4, оп­ре­де­лен­ная в мо­ду­ле parallel_map (но не экс­пор­ти­руе­мая из него):

portion_worker(Fun, SourcePortion, Index, MasterPid) ->

DestPortion = lists:map(Fun, SourcePortion),

MasterPid ! {result, Index, DestPortion}.

Так как ра­бо­чие про­цес­сы у нас опять же «од­но­ра­зо­вые», то вы­пол­няе­мая ими функ­ция очень про­ста: мы вы­чис­ля­ем ре­зуль­тат опе­ра­ции ото­бра­жения пор­ции и воз­вра­ща­ем его глав­но­му про­цес­су при по­мо­щи по­сыл­ки со­об­щения ви­да {result, Index, DestPortion }, где Index – ин­декс ис­ход­ной пор­ции дан­ных, DestPortion – ре­зуль­тат при­менения опе­ра­ции ото­бра­жения к ис­ход­ной пор­ции.

Про­ве­рим, что но­вая мно­го­за­дач­ная вер­сия функ­ции map ра­бо­та­ет пра­виль­но. Для это­го ском­пи­ли­ру­ем со­от­вет­ст­вую­щие мо­ду­ли и за­пустим кон­соль сре­ды вы­полнения язы­ка Erlang. Так как у функ­ции parallel_map:portion_pmap/3 оп­ре­де­ле­но три ва­ри­ан­та, необ­хо­ди­мо про­ве­рить ра­бо­ту их всех. Начнем с пер­во­го ва­ри­ан­та, об­ра­ба­ты­вающ­его слу­чай пустого ис­ход­ного спи­ска. Вы­зов parallel_map:portion_pmap(fun(Item) -> lists:reverse(Item) end, [], 4) воз­вра­ща­ет пустой спи­сок, как и ожи­да­лось. Вто­рой ва­ри­ант – когда ко­ли­че­­ст­во эле­мен­тов в спи­ске мень­ше раз­мера пор­ции (тогда до­полнитель­ных про­цес­сов мы не соз­да­ем, а все вы­чис­ления вы­пол­ня­ем в вы­зы­ваю­щем про­цес­се). Вы­зов parallel_map:portion_pmap(fun(Item) -> lists:reverse(Item) end, [“str13”, “str667”], 4) вернет спи­сок [«31rts”, “766rts”], как и ожи­да­ет­ся. Так как спи­сок со­дер­жит 2 эле­мен­та, а раз­мер пор­ции 4, то мы мо­жем быть уве­ре­ны, что наш вы­зов бу­дет вы­полнен вто­рым ва­ри­ан­том функ­ции parallel_map:portion_pmap/3. И, на­конец, про­ве­рим по­следний ва­ри­ант функ­ции parallel_map:portion_pmap/3. Вы­зов parallel_map:portion_pmap(fun(Item) -> lists:reverse(Item) end, [“str13”, “str67”, “str667”, “str909”], 2) вернет нам спи­сок [“31rts”, “76rts”, “766rts”, “909rts”]. Оче­вид­но, что это зна­чение яв­ля­ет­ся пра­виль­ным. При по­следнем вы­зо­ве раз­мер пор­ции – 2, а ис­ход­ный спи­сок со­дер­жит 4 эле­мен­та; то есть соз­дутся два ра­бо­чих по­то­ка для вы­полнения опе­ра­ции ото­бра­жения ка­ж­дой пор­ции дан­ных.

Да­вай­те внима­тель­но по­смот­рим на соз­дан­ные на­ми вы­ше мно­го­за­дач­ные вер­сии функ­ций map и reduce и сравним, как эти ме­то­ды реа­ли­зу­ют свою функ­цио­наль­ность (сравнивать, что эти ме­то­ды де­ла­ют, оче­вид­но, не име­ет смыс­ла). В обо­их слу­ча­ях у нас есть глав­ный про­цесс (он же про­цесс, в ко­то­ром иниции­ро­вал­ся вы­зов функ­ции) и несколь­ко вспо­мо­га­тель­ных «од­но­ра­зо­вых» ра­бо­чих про­цес­са. В обо­их слу­ча­ях в глав­ном про­цес­се мы раз­би­ва­ем дан­ные на пор­ции, соз­да­ем нужное ко­ли­че­­ст­во ра­бо­чих про­цес­сов и за­даний для них, со­би­ра­ем ре­зуль­та­ты ра­бо­ты от всех ра­бо­чих про­цес­сов и, на­конец, пре­об­ра­зо­вы­ва­ем со­б­ран­ные про­ме­жу­точ­ные ре­зуль­та­ты в ито­го­вый ре­зуль­тат. А в ра­бо­чих про­цес­сах, опять же в обо­их слу­ча­ях, мы вы­пол­ня­ем за­дание, от­сы­ла­ем ре­зуль­тат ра­бо­ты об­рат­но глав­но­му про­цес­су, и все.

• Метамодернизм в позднем творчестве В.Г. Сорокина
• ЛитРПГ - последняя отрыжка постмодерна
• "Ричард III и семиотика"
• 3D-визуализация обложки Ridero создаем обложку книги при работе над самиздатом.
• Архитектура метамодерна - говоря о современном искусстве, невозможно не поговорить об архитектуре. В данной статье будет отмечено несколько интересных принципов, характерных для построек "новой волны", столь притягательных и скандальных.
• Литература
• Метамодерн
• Рокер-Прометей против изначального зла в «Песне про советскую милицию» Вени Дркина, Автор: Нина Ищенко, к.ф.н, член Союза Писателей ЛНР - перепубликация из журнала "Топос".
• Как избавиться от комаров? Лучшие типы ловушек.
• Что делать если роблокс вылетает на windows
• Что делать, если ребенок смотрит порно?
• Почему собака прыгает на людей при встрече?
• Какое масло лить в Задний дифференциал (мост) Visco diff 38434AA050
• О чем может рассказать хвост вашей кошки?
• Верветки
• Отчетность бюджетных учреждений при закупках по Закону № 223-ФЗ
• Срок исковой давности как правильно рассчитать
• Дмитрий Патрушев минсельхоз будет ли преемником Путина
• Кто такой Владислав Поздняков? Что такое "Мужское Государство" и почему его признали экстремистским в России?
• Как правильно выбрать машинное масло в Димитровграде?
• Как стать богатым и знаменитым в России?
• Почему фильм "Пипец" (Kick-Ass) стал популярен по всему миру?
• Как стать мудрецом?
• Как правильно установить FreeBSD
• Как стать таким как Путин?
• Где лучше жить - в Димитровграде или в Ульяновске?
• Почему город Димитровград так называется?
• Что такое метамодерн?
• ВАЖНО! Временное ограничение движения автотранспортных средств в Димитровграде
• Тарифы на электроэнергию для майнеров предложено повысить

Вид­но, что оба эти ме­то­да ор­ганизу­ют свою ра­бо­ту оди­на­ко­вым об­ра­зом. Они от­ли­ча­ют­ся толь­ко функ­ци­ей, об­ра­ба­ты­ваю­щей пор­ции дан­ных в ра­бо­чих про­цес­сах, и функ­ци­ей, пре­об­ра­зо­вы­ваю­щей про­ме­жу­точ­ные ре­зуль­та­ты в ито­го­вый ре­зуль­тат. В реа­ли­за­ции функ­ции map для об­ра­бот­ки пор­ции дан­ных в ра­бо­чем про­цес­се ис­поль­зу­ет­ся функ­ция lists:map/2, а для пре­об­ра­зо­вания про­ме­жу­точ­ных ре­зуль­та­тов в ито­го­вый ре­зуль­тат – функ­ция lists:append/1. В реа­ли­за­ции функ­ции reduce в обо­их слу­ча­ях применя­ет­ся функ­ция lists:foldl/3, толь­ко с раз­ны­ми па­ра­мет­ра­ми. Ло­гич­но с­просить: а зачем мы сей­час сравнива­ем на­ши реа­ли­за­ции функ­ций map и reduce? От­вет, по­жа­луй, оче­ви­ден: во-пер­вых, мы хо­тим из­бе­жать дуб­ли­ро­вания ко­да в уже су­ще­ст­вую­щих реа­ли­за­ци­ях ме­то­дов map и reduce, а во-вто­рых, хо­тим в дальней­шем соз­да­вать па­рал­лель­ные вер­сии еще ка­ких-ли­бо ме­то­дов с минималь­ны­ми за­тра­та­ми. В на­шем слу­чае вид­но, что мы мо­жем вы­де­лить об­щую часть в реа­ли­за­ции ме­то­дов parallel_map:portion_pmap/3 и parallel_reduce:portion_reduce/4. Все вы­де­ляе­мые об­щие ме­то­ды мы по­ме­ща­ем в мо­дуль parallel_portion_helper (и, со­от­вет­ст­вен­но, в файл parallel_portion_helper.erl).

Начнем с функ­ции, ко­то­рую вы­пол­ня­ют ра­бо­чие про­цес­сы. Для соз­дания ее об­щей вер­сии доста­точ­но за­менить кон­крет­ные функ­ции, ис­поль­зуе­мые для об­ра­бот­ки пор­ции в ра­бо­чих про­цес­сах на неко­то­рую функ­цию, пе­ре­да­вае­мую как па­ра­метр:

portion_worker(Fun, SourcePortion, Index, MasterPid) ->

DestPortion = Fun(SourcePortion),

MasterPid ! {result, Index, DestPortion}.

Здесь па­ра­метр Fun и яв­ля­ет­ся той са­мой функ­ци­ей, ко­то­рая об­ра­ба­ты­ва­ет вход­ную пор­цию дан­ных. Сле­ду­ет за­ме­тить, что эта функ­ция не экс­пор­ти­ру­ет­ся из мо­ду­ля parallel_portion_helper. Те­перь вы­де­лим об­щую часть из ра­бо­чих функ­ций глав­ных про­цес­сов (и, со­от­вет­ст­вен­но, то­чек вхо­да) для на­ших реа­ли­за­ций ме­то­дов map и reduce. Как уже го­во­ри­лось, ра­бо­чие функ­ции глав­ных про­цес­сов от­ли­ча­ют­ся толь­ко сле­дую­щи­ми ас­пек­та­ми: функ­ци­ей, ко­то­рая об­ра­ба­ты­ва­ет пор­ции дан­ных в ра­бо­чих про­цес­сах, и функ­ци­ей, ко­то­рая пре­об­ра­зо­вы­ва­ет про­ме­жу­точ­ные ре­зуль­таты в ито­го­вый ре­зуль­тат. Оче­вид­но, что об­щая часть долж­на со­дер­жать обе эти функ­ции в ка­че­­ст­ве па­ра­мет­ров. С уче­том все­го ска­зан­но­го, об­щая часть ра­бо­чей функ­ции глав­но­го по­то­ка долж­на вы­гля­деть сле­дую­щим об­ра­зом (ес­те­ст­вен­но, что эта функ­ция яв­ля­ет­ся экс­пор­ти­руе­мой из мо­ду­ля parallel_portion_helper):

portion_core(WorkerFun, FinalAggrFun, SourceList, PortionSize) ->

process_flag(trap_exit, true),

MasterPid = self(),

PortionCount = parallel_common:calc_portion_count(length(SourceList), PortionSize),

PreparedData = parallel_common:prepare_data(PortionSize, SourceList),

lists:foreach(fun({Index, Portion}) -> spawn_link(fun() -> portion_worker(WorkerFun, Portion, Index, MasterPid) end) end, PreparedData),

EmptyStorage = array:new([{size, PortionCount}, {fixed, true}, {default, none}]),

FullStorage = parallel_common:collect_result(EmptyStorage, PortionCount),

process_flag(trap_exit, false),

FinalAggrFun(array:to_list(FullStorage)).

Здесь па­ра­метр WorkerFun яв­ля­ет­ся функ­ци­ей, ко­то­рая при­ме­ня­ет­ся для об­ра­бот­ки пор­ций ис­ход­ных дан­ных в ра­бо­чих про­цес­сах, а па­ра­метр FinalAggrFun – функ­ци­я для пре­об­ра­зо­вания про­ме­жу­точ­ных ре­зуль­та­тов в ито­го­вый ре­зуль­тат. По­ми­мо этих двух па­ра­мет­ров, эта функ­ция принима­ет так­же ис­ход­ный спи­сок SourceList и раз­мер пор­ции PortionSize. Мо­жет возник­нуть во­прос: мо­жем ли мы вынести в ме­тод parallel_portion_helper:portion_core/4 до­полнитель­ные ва­ри­ан­ты, ко­то­рые бы­ли в ме­то­дах parallel_map:portion_pmap/3 и parallel_reduce:portion_reduce/4 и пред­на­зна­ча­лись для об­ра­бот­ки си­туа­ций, когда ис­ход­ный спи­сок ли­бо пуст, ли­бо его раз­мер не боль­ше раз­ме­ра пор­ции? Для от­ве­та сравним ва­ри­ан­ты функ­ций parallel_map: portion_pmap/3 и parallel_reduce:portion_reduce/4, ко­то­рые об­ра­ба­ты­ва­ют си­туа­цию пусто­го спи­ска с дан­ны­ми. Функ­ция parallel_map:portion_pmap/3 в этом слу­чае воз­вра­ща­ет пустой спи­сок, а функ­ция parallel_reduce:portion_reduce/4 – на­чаль­ное зна­чение опе­ра­ции сверт­ки. Вид­но, что для это­го ва­ри­ан­та воз­вра­щае­мые зна­чения спе­ци­фич­ны. Точ­но так же мож­но уви­деть спе­ци­фи­ку и в ва­ри­ан­тах функ­ций parallel_map:portion_pmap/3 и parallel_reduce:portion_reduce/4, ко­то­рые об­ра­ба­ты­ва­ют си­туа­цию, когда раз­мер спи­ска не пре­вы­ша­ет раз­ме­ра пор­ции. Имен­но по этой при­чине та­ких ва­ри­ан­тов нет в функ­ции parallel_portion_helper:portion_core/4.

Те­перь по­смот­рим, как мож­но пе­ре­пи­сать функ­ции parallel_map:portion_pmap/3 и parallel_reduce:portion_reduce/4, ис­поль­зуя соз­дан­ную функ­цию parallel_portion_helper:portion_core/4. Но­вые (пе­ре­пи­сан­ные) функ­ции бу­дут на­зы­вать­ся parallel_map:portion_gen_pmap/3 и parallel_reduce:portion_gen_reduce/4, со­от­вет­ст­вен­но. Реа­ли­за­ция parallel_map:portion_gen_pmap/3 функ­ции вы­гля­дит сле­дую­щим об­ра­зом:

portion_gen_pmap(_Fun, [], _PortionSize) -> [];

portion_gen_pmap(Fun, SourceList, PortionSize)

when length(SourceList) =< PortionSize ->

lists:map(Fun, SourceList);

portion_gen_pmap(Fun, SourceList, PortionSize) ->

WorkerFun = fun(SourcePortion) -> lists:map(Fun, SourcePortion) end,

parallel_portion_helper:portion_core(WorkerFun, fun lists:append/1, SourceList, PortionSize).

Здесь функ­ция WorkerFun соз­да­ет­ся на осно­ве функ­ции lists:map/2, а функ­ци­ей FinalAggrFun яв­ля­ет­ся функ­ция lists: append/1. Ана­ло­гич­ным об­ра­зом вы­гля­дит реа­ли­за­ция функ­ции parallel_reduce:portion_gen_reduce/4:

portion_gen_reduce(_Fun, [], {InitValue, _PortionInitValue}, _PortionSize) -> InitValue;

portion_gen_reduce(Fun, SourceList, {InitValue, _PortionInitValue}, PortionSize)

when length(SourceList) =< PortionSize ->

lists:foldl(Fun, InitValue, SourceList);

portion_gen_reduce(Fun, SourceList, {InitValue, PortionInitValue}, PortionSize) ->

ReduceFun = fun(List) -> lists:foldl(Fun, InitValue, List) end,

PortionReduceFun = fun(List) -> lists:foldl(Fun, PortionInitValue, List) end,

parallel_portion_helper:portion_core(PortionReduceFun, ReduceFun, SourceList, PortionSize).

Здесь и функ­ция WorkerFun, и функ­ция FinalAggrFun соз­да­ют­ся на осно­ве функ­ции lists:foldl/3; глав­ное от­ли­чие ме­ж­ду эти­ми по­строения­ми в том, что в ка­че­­ст­ве па­ра­мет­ра Acc0 (на­чаль­ное зна­чение) в пер­вом слу­чае бе­рет­ся «нуль» опе­ра­ции сверт­ки, а во вто­ром – на­чаль­ное зна­чение опе­ра­ции сверт­ки.

Для тес­ти­ро­вания ра­бо­ты функ­ций parallel_map:portion_gen_pmap/3 и parallel_reduce:portion_gen_reduce/4 мы мо­жем ис­поль­зо­вать те же сце­на­рии, что и для тес­ти­ро­вания функ­ций parallel_map:portion_pmap/3 и parallel_reduce:portion_reduce/4. По­это­му дуб­ли­ро­вать ре­зуль­та­ты тес­ти­ро­вания функ­ций parallel_map:portion_gen_pmap/3 и parallel_reduce:portion_gen_reduce/4 мы здесь не бу­дем (же­лаю­щие мо­гут про­вес­ти его са­ми и убе­дить­ся, что все ра­бо­та­ет, как на­до).

Се­го­дня мы сде­ла­ли оче­ред­ной шаг в на­шем прак­ти­ку­ме: соз­да­ли мно­го­за­дач­ные вер­сии функ­ций map и reduce, ко­то­рые об­ра­ба­ты­ва­ют пор­ции ис­ход­ных дан­ных па­рал­лель­но. На­страи­вая раз­мер пор­ции, мы мо­жем управ­лять про­из­во­ди­тель­но­стью на­ших функ­ций (мы об этом по­го­во­рим в од­ном из сле­дую­щих но­ме­ров). Бо­лее то­го, мы смог­ли най­ти и вы­де­лить об­щее яд­ро у со­от­вет­ст­вую­щих вер­сий функ­ций map и reduce. Важ­ность это­го ре­зуль­та­та в том, что при соз­дании всех дальней­ших мно­го­за­дач­ных вер­сий функ­ций map и reduce мы бу­дем соз­да­вать для них неко­то­рое об­щее яд­ро. Это по­мо­жет из­бе­жать дуб­ли­ро­вания ко­да и об­лег­чит соз­дание мно­го­за­дач­ных вер­сий ка­ких-ли­бо еще функ­ций (но об этом мы по­го­во­рим в сле­дую­щий раз). |