Карактеристики на јазикот Q и KDB+ користејќи го примерот на услуга во реално време

За тоа што е базата на KDB+, програмскиот јазик Q, кои се нивните силни и слаби страни, можете да прочитате во моите претходни Член и накратко во воведот. Во написот, ќе имплементираме услуга на Q што ќе го обработува дојдовниот поток на податоци и ќе пресметува различни функции на агрегација секоја минута во режимот „во реално време“ (т.е., ќе има време да пресмета сè пред следниот дел од податоците). Главната карактеристика на Q е тоа што е векторски јазик кој ви овозможува да работите не со единечни објекти, туку со нивните низи, низи од низи и други сложени објекти. Јазиците како што се Q и неговите роднини K, J, APL се познати по нивната краткост. Честопати, програма што зафаќа неколку екрани со код на познат јазик како Java може да се напише на нив во неколку линии. Ова е она што сакам да го покажам во оваа статија.

Вовед

KDB+ е колонообразна база на податоци фокусирана на многу големи количини на податоци, подредени на специфичен начин (првенствено според времето). Се користи првенствено во финансиски институции - банки, инвестициски фондови, осигурителни компании. Јазикот Q е внатрешниот јазик на KDB+ кој ви овозможува ефективно да работите со овие податоци. Идеологијата Q е краткост и ефикасност, додека јасноста е жртвувана. Ова се оправдува со фактот дека векторскиот јазик во секој случај ќе биде тешко разбирлив, а краткоста и богатството на снимката ви овозможува да видите многу поголем дел од програмата на еден екран, што на крајот го олеснува разбирањето.

Во оваа статија имплементираме полноправна програма во Q и можеби ќе сакате да ја испробате. За да го направите ова, ќе ви треба вистинскиот Q. Можете да ја преземете бесплатната 32-битна верзија на веб-страницата на компанијата kx - www.kx.com. Таму, доколку сте заинтересирани, ќе најдете референтни информации за Q, книгата П За смртници и разни написи на оваа тема.

Проблем изјава

Постои извор кој испраќа табела со податоци на секои 25 милисекунди. Бидејќи KDB+ се користи првенствено во финансиите, ќе претпоставиме дека ова е табела на трансакции (трговија), која ги има следните колони: време (време во милисекунди), sym (ознака на компанијата на берзата - IBM,, AAPL,…), цена (цената по која се купени акциите), големина (големина на трансакцијата). Интервалот од 25 милисекунди е произволен, не е премногу мал и не е премногу долг. Неговото присуство значи дека податоците доаѓаат до услугата веќе баферирани. Би било лесно да се имплементира тампонирање на сервисната страна, вклучително и динамично баферирање во зависност од тековното оптоварување, но за едноставност, ќе се фокусираме на фиксен интервал.

Услугата мора да брои секоја минута за секој дојдовен симбол од колоната sym збир на функции за собирање - максимална цена, просечна цена, големина на сума итн. корисни информации. За едноставност, ќе претпоставиме дека сите функции може да се пресметуваат постепено, т.е. за да се добие нова вредност, доволно е да се знаат два броја - старите и дојдовните вредности. На пример, функциите max, average, sum го имаат ова својство, но средната функција не.

Исто така, ќе претпоставиме дека дојдовниот проток на податоци е временски нареден. Ова ќе ни даде можност да работиме само со последната минута. Во пракса, доволно е да можете да работите со тековните и претходните минути во случај некои ажурирања да доцнат. За едноставност, нема да го разгледаме овој случај.

Функции на агрегација

Потребните функции за агрегација се наведени подолу. Зедов што е можно повеќе од нив за да го зголемам оптоварувањето на услугата:

• висока – максимална цена – максимална цена за минута.
• ниска – мин цена – минимална цена за минута.
• прва Цена – прва цена – прва цена за минута.
• lastPrice – последна цена – последна цена за минута.
• firstSize – прва големина – прва трговска големина во минута.
• lastSize – последна големина – последната големина на тргување за една минута.
• numTrades – брои i – број на занаети во минута.
• волумен – големина на сума – збир на големини на трговија во минута.
• pvolume – сума цена – збир на цени во минута, потребна за avgPrice.
• – сума промет цена*големина – вкупен обем на трансакции во минута.
• avgPrice – pvolume%numTrades – просечна цена по минута.
• avgSize – волумен%numTrades – просечна големина на тргување во минута.
• vwap – промет%волумен – просечна цена во минута пондерирана според големината на трансакцијата.
• cumVolume – сума волумен – акумулирана големина на трансакции во текот на целото време.

Ајде веднаш да разговараме за една неочигледна точка - како да се иницијализираат овие колони за прв пат и за секоја следна минута. Некои колони од типот firstPrice мора да се иницијализираат за да бидат нула секој пат; нивната вредност е недефинирана. Другите типови јачина мора секогаш да бидат поставени на 0. Има и колони за кои е потребен комбиниран пристап - на пример, cumVolume мора да се копира од претходната минута, а за првата да се постави на 0. Ајде да ги поставиме сите овие параметри користејќи ги податоците од речникот тип (аналогно на запис):

// list ! list – создать словарь, 0n – float null, 0N – long null, `sym – тип символ, `sym1`sym2 – список символов
initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time; // список всех вычисляемых колонок, reverse объяснен ниже

Додадов sym и време во речникот за погодност, сега initWith е готова линија од конечната збирна табела, каде што останува да се постават точниот симбол и време. Можете да го користите за да додадете нови редови на табелата.

Ќе ни требаат aggCols кога креираме функција за агрегација. Списокот мора да биде превртен поради редоследот по кој се оценуваат изразите во Q (од десно кон лево). Целта е да се обезбеди дека пресметката оди од висок до cumVolume, бидејќи некои колони зависат од претходните.

Колони што треба да се копираат во нова минута од претходната, за погодност се додава колоната sym:

rollColumns:`sym`cumVolume;

Сега да ги поделиме колоните во групи според тоа како треба да се ажурираат. Може да се разликуваат три вида:

1. Акумулатори (волумен, промет,..) – мора да ја додадеме дојдовната вредност на претходната.
2. Со посебна точка (висока, ниска, ..) – првата вредност во минута се зема од дојдовните податоци, а останатите се пресметуваат со помош на функцијата.
3. Одмор. Секогаш се пресметува со помош на функција.

Ајде да дефинираме променливи за овие класи:

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

Редоследот на пресметка

Збирната табела ќе ја ажурираме во две фази. За ефикасност, прво ја намалуваме дојдовната табела така што има само еден ред за секој знак и минута. Фактот дека сите наши функции се инкрементални и асоцијативни гарантира дека резултатот од овој дополнителен чекор нема да се промени. Можете да ја намалите табелата користејќи изберете:

select high:max price, low:min price … by sym,time.minute from table

Овој метод има недостаток - множеството пресметани колони е претходно дефинирано. За среќа, во Q, изберете исто така се имплементира како функција каде што можете да ги замените динамички креираните аргументи:

?[table;whereClause;byClause;selectClause]

Нема да го опишам детално форматот на аргументите; во нашиот случај, само изразите со и изберете ќе бидат нетривијални и тие треба да бидат речници на формите колони!изрази. Така, функцијата за собирање може да се дефинира на следниов начин:

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size"); // each это функция map в Q для одного списка
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

За јасност, ја користев функцијата за анализа, која претвора низа со израз Q во вредност што може да се пренесе на функцијата eval и која е потребна во функцијата изберете. Исто така, забележете дека предпроцесот е дефиниран како проекција (т.е. функција со делумно дефинирани аргументи) на функцијата изберете, недостасува еден аргумент (табелата). Ако примениме претпроцес на табела, ќе добиеме компресирана табела.

Втората фаза е ажурирање на збирната табела. Ајде прво да го напишеме алгоритмот во псевдокод:

for each sym in inputTable
  idx: row index in agg table for sym+currentTime;
  aggTable[idx;`high]: aggTable[idx;`high] | inputTable[sym;`high];
  aggTable[idx;`volume]: aggTable[idx;`volume] + inputTable[sym;`volume];
  …

Во Q, вообичаено е да се користат функции за мап/намалување наместо циклуси. Но, бидејќи Q е векторски јазик и лесно можеме да ги примениме сите операции на сите симболи одеднаш, тогаш на првото приближување можеме да направиме без јамка воопшто, извршувајќи операции на сите симболи одеднаш:

idx:calcIdx inputTable;
row:aggTable idx;
aggTable[idx;`high]: row[`high] | inputTable`high;
aggTable[idx;`volume]: row[`volume] + inputTable`volume;
…

Но, можеме да одиме понатаму, Q има единствен и исклучително моќен оператор - генерализираниот оператор за доделување. Ви овозможува да менувате збир на вредности во сложена структура на податоци користејќи листа на индекси, функции и аргументи. Во нашиот случај изгледа вака:

idx:calcIdx inputTable;
rows:aggTable idx;
// .[target;(idx0;idx1;..);function;argument] ~ target[idx 0;idx 1;…]: function[target[idx 0;idx 1;…];argument], в нашем случае функция – это присваивание
.[aggTable;(idx;aggCols);:;flip (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

За жал, за да доделите на табела потребна ви е листа на редови, а не колони, и мора да ја префрлите матрицата (список на колони во список со редови) користејќи ја функцијата превртување. Ова е скапо за голема табела, па наместо тоа, применуваме генерализирана задача за секоја колона посебно, користејќи ја функцијата за мапа (која изгледа како апостроф):

.[aggTable;;:;]'[(idx;)each aggCols; (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

Повторно користиме функционална проекција. Исто така, забележете дека во Q, креирањето листа е исто така функција и можеме да ја повикаме користејќи ја функцијата every(map) за да добиеме листа на списоци.

За да се осигураме дека множеството пресметани колони не е фиксирано, динамички ќе го создадеме горенаведениот израз. Ајде прво да ги дефинираме функциите за пресметување на секоја колона, користејќи ги променливите ред и inp за да се однесуваат на збирните и влезните податоци:

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!
 ("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");

Некои колони се посебни; нивната прва вредност не треба да се пресметува со функцијата. Можеме да одредиме дека е прв по редот [`numTrades] колона - ако содржи 0, тогаш вредноста е прва. Q има функција за одбирање - ?[Boolean list;list1;list2] - која избира вредност од листата 1 или 2 во зависност од состојбата во првиот аргумент:

// high -> ?[isFirst;inp`high;row[`high]|inp`high]
// @ - тоже обобщенное присваивание для случая когда индекс неглубокий
@[`aggExpression;specialCols;{[x;y]"?[isFirst;inp`",y,";",x,"]"};string specialCols];

Овде повикав генерализирана задача со мојата функција (израз во кадрави загради). Ја добива моменталната вредност (првиот аргумент) и дополнителен аргумент, кој го пренесувам во четвртиот параметар.

Ајде да додадеме звучници за батерии посебно, бидејќи функцијата е иста за нив:

// volume -> row[`volume]+inp`volume
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;

Ова е нормална задача според Q стандардите, но јас доделувам листа на вредности одеднаш. Конечно, ајде да ја создадеме главната функција:

// ":",/:aggExprs ~ map[{":",x};aggExpr] => ":row[`high]|inp`high" присвоим вычисленное значение переменной, потому что некоторые колонки зависят от уже вычисленных значений
// string[cols],'exprs ~ map[,;string[cols];exprs] => "high:row[`high]|inp`high" завершим создание присваивания. ,’ расшифровывается как map[concat]
// ";" sv exprs – String from Vector (sv), соединяет список строк вставляя “;” посредине
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}";

Со овој израз динамички креирам функција од низа што го содржи изразот што го дадов погоре. Резултатот ќе изгледа вака:

{[aggTable;idx;inp] rows:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols ;(cumVolume:row[`cumVolume]+inp`cumVolume;… ; high:?[isFirst;inp`high;row[`high]|inp`high])]}

Редоследот на оценување на колоната е превртен бидејќи во Q редоследот на оценување е од десно кон лево.

Сега имаме две главни функции неопходни за пресметки, само треба да додадеме малку инфраструктура и услугата е подготвена.

Последни чекори

Имаме функции за претпроцесирање и ажурирање на Agg кои ја вршат целата работа. Но, сепак е неопходно да се обезбеди правилна транзиција низ минути и да се пресметаат индексите за агрегација. Пред сè, да ја дефинираме функцијата иницирање:

init:{
  tradeAgg:: 0#enlist[initWith]; // создаем пустую типизированную таблицу, enlist превращает словарь в таблицу, а 0# означает взять 0 элементов из нее
  currTime::00:00; // начнем с 0, :: означает, что присваивание в глобальную переменную
  currSyms::`u#`symbol$(); // `u# - превращает список в дерево, для ускорения поиска элементов
  offset::0; // индекс в tradeAgg, где начинается текущая минута 
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg; // кэш для последних значений roll колонок, таблица с ключом sym
 }

Ние, исто така, ќе ја дефинираме функцијата за тркалање, која ќе ја промени тековната минута:

roll:{[tm]
  if[currTime>tm; :init[]]; // если перевалили за полночь, то просто вызовем init
  rollCache,::offset _ rollColumns#tradeAgg; // обновим кэш – взять roll колонки из aggTable, обрезать, вставить в rollCache
  offset::count tradeAgg;
  currSyms::`u#`$();
 }

Ќе ни треба функција за додавање нови знаци:

addSyms:{[syms]
  currSyms,::syms; // добавим в список известных
  // добавим в таблицу sym, time и rollColumns воспользовавшись обобщенным присваиванием.
  // Функция ^ подставляет значения по умолчанию для roll колонок, если символа нет в кэше. value flip table возвращает список колонок в таблице.
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime), (initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 }

И, конечно, функцијата upd (традиционалното име за оваа функција за Q услугите), која клиентот ја повикува да додаде податоци:

upd:{[tblName;data] // tblName нам не нужно, но обычно сервис обрабатывает несколько таблиц 
  tm:exec distinct time from data:() xkey preprocess data; // preprocess & calc time
  updMinute[data] each tm; // добавим данные для каждой минуты
};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm]; // поменяем минуту, если необходимо
  data:select from data where time=tm; // фильтрация
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms]; // новые символы
  updateAgg[`tradeAgg;offset+currSyms?syms;data]; // обновим агрегированную таблицу. Функция ? ищет индекс элементов списка справа в списке слева.
 };

Тоа е се. Еве го целосниот код на нашата услуга, како што ветивме, само неколку линии:

initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time;
rollColumns:`sym`cumVolume;

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size");
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");
@[`aggExpression;specialCols;{"?[isFirst;inp`",y,";",x,"]"};string specialCols];
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}"; / '

init:{
  tradeAgg::0#enlist[initWith];
  currTime::00:00;
  currSyms::`u#`symbol$();
  offset::0;
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg;
 };
roll:{[tm]
  if[currTime>tm; :init[]];
  rollCache,::offset _ rollColumns#tradeAgg;
  offset::count tradeAgg;
  currSyms::`u#`$();
 };
addSyms:{[syms]
  currSyms,::syms;
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime),(initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 };

upd:{[tblName;data] updMinute[data] each exec distinct time from data:() xkey preprocess data};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm];
  data:select from data where time=tm;
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms];
  updateAgg[`tradeAgg;offset+currSyms?syms;data];
 };

Тестирање

Ајде да ги провериме перформансите на услугата. За да го направите ова, ајде да го извршиме во посебен процес (ставете го кодот во датотеката service.q) и повикајте ја функцијата init:

q service.q –p 5566

q)init[]

Во друга конзола, започнете го вториот процес Q и поврзете се со првата:

h:hopen `:host:5566
h:hopen 5566 // если оба на одном хосте

Прво, ајде да создадеме листа на симболи - 10000 парчиња и да додадеме функција за да создадеме случајна табела. Во втората конзола:

syms:`IBM`AAPL`GOOG,-9997?`8
rnd:{[n;t] ([] sym:n?syms; time:t+asc n#til 25; price:n?10f; size:n?10)}

Додадов три вистински симболи на листата за полесно да ги барам во табелата. Функцијата rnd создава случајна табела со n редови, каде што времето варира од t до t+25 милисекунди.

Сега можете да се обидете да испраќате податоци до услугата (додајте ги првите десет часа):

{h (`upd;`trade;rnd[10000;x])} each `time$00:00 + til 60*10

Можете да проверите во услугата дека табелата е ажурирана:

c 25 200
select from tradeAgg where sym=`AAPL
-20#select from tradeAgg where sym=`AAPL

Резултатот е:

sym|time|high|low|firstPrice|lastPrice|firstSize|lastSize|numTrades|volume|pvolume|turnover|avgPrice|avgSize|vwap|cumVolume
--|--|--|--|--|--------------------------------
AAPL|09:27|9.258904|9.258904|9.258904|9.258904|8|8|1|8|9.258904|74.07123|9.258904|8|9.258904|2888
AAPL|09:28|9.068162|9.068162|9.068162|9.068162|7|7|1|7|9.068162|63.47713|9.068162|7|9.068162|2895
AAPL|09:31|4.680449|0.2011121|1.620827|0.2011121|1|5|4|14|9.569556|36.84342|2.392389|3.5|2.631673|2909
AAPL|09:33|2.812535|2.812535|2.812535|2.812535|6|6|1|6|2.812535|16.87521|2.812535|6|2.812535|2915
AAPL|09:34|5.099025|5.099025|5.099025|5.099025|4|4|1|4|5.099025|20.3961|5.099025|4|5.099025|2919

Ајде сега да извршиме тестирање на оптоварување за да откриеме колку податоци услугата може да обработува во минута. Да ве потсетам дека интервалот за ажурирање го поставивме на 25 милисекунди. Според тоа, услугата мора (во просек) да се вклопи во најмалку 20 милисекунди по ажурирање за да им даде време на корисниците да побараат податоци. Внесете го следново во вториот процес:

tm:10:00:00.000
stressTest:{[n] 1 string[tm]," "; times,::h ({st:.z.T; upd[`trade;x]; .z.T-st};rnd[n;tm]); tm+:25}
start:{[n] times::(); do[4800;stressTest[n]]; -1 " "; `min`avg`med`max!(min times;avg times;med times;max times)}

4800 е две минути. Може да се обидете прво да трчате за 1000 редови на секои 25 милисекунди:

start 1000

Во мојот случај, резултатот е околу неколку милисекунди по ажурирање. Така, веднаш ќе го зголемам бројот на редови на 10.000:

start 10000

Резултатот е:

min| 00:00:00.004
avg| 9.191458
med| 9f
max| 00:00:00.030

Повторно, ништо посебно, но ова е 24 милиони линии во минута, 400 илјади во секунда. Повеќе од 25 милисекунди, ажурирањето забави само 5 пати, очигледно кога се смени минутата. Да се ​​зголемиме на 100.000:

start 100000

Резултатот е:

min| 00:00:00.013
avg| 25.11083
med| 24f
max| 00:00:00.108
q)sum times
00:02:00.532

Како што можете да видите, услугата едвај се снајде, но сепак успева да остане на површина. Таков обем на податоци (240 милиони редови во минута) е исклучително голем; во такви случаи, вообичаено е да се лансираат неколку клонови (или дури и десетици клонови) на услугата, од кои секој обработува само дел од ликовите. Сепак, резултатот е импресивен за толкуваниот јазик кој се фокусира првенствено на складирање податоци.

Може да се појави прашањето зошто времето расте нелинеарно со големината на секое ажурирање. Причината е што функцијата shrink е всушност функција C, што е многу поефикасна од updateAgg. Почнувајќи од одредена големина на ажурирање (околу 10.000), updateAgg го достигнува својот плафон и тогаш времето на неговото извршување не зависи од големината на ажурирањето. Поради прелиминарниот чекор Q услугата може да ги свари таквите количини на податоци. Ова нагласува колку е важно да се избере вистинскиот алгоритам кога се работи со големи податоци. Друга точка е правилното складирање на податоци во меморијата. Доколку податоците не беа складирани колонообразно или не беа нарачани со време, тогаш ќе се запознаеме со такво нешто како промашување на кешот на TLB - отсуство на адреса на мемориска страница во кешот за адреси на процесорот. Пребарувањето на адреса трае околу 30 пати подолго ако е неуспешно, а ако податоците се расфрлани, може да ја забави услугата неколку пати.

Заклучок

Во оваа статија, покажав дека базата на податоци KDB+ и Q се погодни не само за складирање големи податоци и лесен пристап до нив преку изберете, туку и за создавање услуги за обработка на податоци кои се способни да сварат стотици милиони редови/гигабајти податоци дури и во еден единствен Q процес. Самиот јазик Q овозможува исклучително концизна и ефикасна имплементација на алгоритми поврзани со обработката на податоците поради неговата векторска природа, вградениот SQL дијалект преведувач и многу успешен сет на библиотечни функции.

Ќе забележам дека горенаведеното е само дел од она што Q може да го направи, има и други уникатни карактеристики. На пример, исклучително едноставен IPC протокол кој ја брише границата помеѓу поединечните процеси Q и ви овозможува да комбинирате стотици од овие процеси во една мрежа, која може да се наоѓа на десетици сервери во различни делови на светот.

Извор: www.habr.com