mpy.openmpi - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

mpy - സന്ദേശം യോറിക്ക് കടന്നുപോകുന്നു

സിനോപ്സിസ്

mpirun -np mp_size എംപി [-ജെ pfile1.i [-ജെ pfile2.i [... ]]] [ -ഐ ഫയൽ1.ഐ [-ഐ ഫയൽ2.ഐ [
... ]]]
mpirun -np mp_size എംപി -ബാച്ച് file.i

വിവരണം

യോറിക് ബേസിക് അല്ലെങ്കിൽ ലിസ്പ് പോലെയുള്ള ഒരു വ്യാഖ്യാന ഭാഷയാണ്, എന്നാൽ വളരെ വേഗതയുള്ളതാണ്. കാണുക യോറിക്ക് (1) മുതൽ
അതിനെക്കുറിച്ച് കൂടുതലറിയുക.
എംപി യുടെ സമാന്തര പതിപ്പാണ് യോറിക് മെസേജ് പാസിംഗ് ഇന്റർഫേസ് (എംപിഐ) അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ദി
ഒരു സമാന്തര ജോലി ആരംഭിക്കുന്നതിനുള്ള കൃത്യമായ വാക്യഘടന നിങ്ങളുടെ MPI പരിതസ്ഥിതിയെ ആശ്രയിച്ചിരിക്കുന്നു. അത് ആയിരിക്കാം
വിളിക്കുന്നതിന് മുമ്പ് ഒരു പ്രത്യേക ഡെമൺ സമാരംഭിക്കേണ്ടത് ആവശ്യമാണ് മിരുൺ അല്ലെങ്കിൽ തത്തുല്യമായ കമാൻഡ്.

വിശദീകരണം
എംപിഐ പാരലൽ പ്രോഗ്രാമിംഗ് ലൈബ്രറിയിലേക്ക് എംപി പാക്കേജ് യോറിക്ക് ഇന്റർഫേസ് ചെയ്യുന്നു. MPI എന്നതിന്റെ അർത്ഥം
സന്ദേശം കടന്നുപോകുന്ന ഇന്റർഫേസ്; യോറിക്കിന്റെ ഒന്നിലധികം സന്ദർഭങ്ങൾ ബന്ധിപ്പിക്കുക എന്നതാണ് ആശയം
സന്ദേശങ്ങൾ വഴി പരസ്പരം ആശയവിനിമയം നടത്തുക. എംപിയ്‌ക്ക് ഒന്നുകിൽ ലളിതവും സമാന്തരവുമായ പ്രകടനം നടത്താൻ കഴിയും
ടാസ്‌ക്കുകൾ ശുദ്ധമായ വ്യാഖ്യാന പ്രോഗ്രാമുകളായി, അല്ലെങ്കിൽ അതിന് ഏകപക്ഷീയമായി സങ്കീർണ്ണമായ സമാഹരണം ആരംഭിക്കാനും നയിക്കാനും കഴിയും
സമാഹരിച്ച MPI API ഉപയോഗിക്കാൻ സൌജന്യമായ പാക്കേജുകൾ. വ്യാഖ്യാനിച്ച API ഉദ്ദേശിച്ചുള്ളതല്ല
ഒരു MPI റാപ്പർ ആകാൻ; പകരം അത് ഏറ്റവും കുറഞ്ഞ അളവിലേക്ക് വലിച്ചെറിയപ്പെടുന്നു.

ഇത് എംപിയുടെ പതിപ്പ് 2 ആണ് (2010-ൽ പുറത്തിറങ്ങിയത്); ഇത് mpy യുടെ 1 പതിപ്പുമായി പൊരുത്തപ്പെടുന്നില്ല
(1990-കളുടെ മധ്യത്തിൽ പുറത്തിറങ്ങി), കാരണം പതിപ്പ് 1 ന് നിരവധി ഡിസൈൻ പിഴവുകൾ ഉണ്ടായിരുന്നു.
റേസ് സാഹചര്യങ്ങളില്ലാതെ പ്രോഗ്രാമുകൾ എഴുതാൻ പ്രയാസമാണ്, ദശലക്ഷക്കണക്കിന് സ്കെയിൽ ചെയ്യാൻ കഴിയില്ല
പ്രോസസ്സറുകളുടെ. എന്നിരുന്നാലും, പതിപ്പ് 1-ന് കീഴിൽ നിങ്ങൾക്ക് മിക്ക പതിപ്പ് 2 എംപി പ്രോഗ്രാമുകളും പ്രവർത്തിപ്പിക്കാൻ കഴിയും
mpy1 സമാന്തര ടാസ്‌ക് (അതായത്
ഏതെങ്കിലും ഫയലിന് മുമ്പ് mp_task-ലേക്കുള്ള ഒരു കോൾ.)

ഉപയോഗം കുറിപ്പുകൾ
MPI പരിതസ്ഥിതി ശരിക്കും സ്റ്റാൻഡേർഡ് പ്രകാരം വ്യക്തമാക്കിയിട്ടില്ല; നിലവിലുള്ള പരിതസ്ഥിതികൾ
വളരെ അസംസ്‌കൃതവും, സംവേദനാത്മകമല്ലാത്ത ബാച്ച് ജോലികളെ ശക്തമായി അനുകൂലിക്കുന്നു. പ്രക്രിയകളുടെ എണ്ണം
MPI ആരംഭിക്കുന്നതിന് മുമ്പ് നിശ്ചയിച്ചു; ഓരോ പ്രക്രിയയ്ക്കും ഒരു റാങ്ക് ഉണ്ട്, 0 മുതൽ ഒന്ന് വരെയുള്ള ഒരു സംഖ്യ
പ്രക്രിയകളുടെ എണ്ണം. സന്ദേശങ്ങൾ അയയ്‌ക്കുന്നതിനുള്ള ഒരു വിലാസമായി നിങ്ങൾ റാങ്കും പ്രക്രിയയും ഉപയോഗിക്കുന്നു
സന്ദേശം സ്വീകരിക്കുന്നത് ഏതൊക്കെ റാങ്കുകളാണ് അതിലേക്ക് സന്ദേശങ്ങൾ അയച്ചതെന്ന് പരിശോധിക്കാൻ കഴിയും, തീർച്ചയായും
ആ സന്ദേശങ്ങൾ സ്വീകരിക്കുക.

ഒരു മെസേജ് പാസിംഗ് പ്രോഗ്രാം എഴുതുന്നതിലെ ഒരു പ്രധാന പ്രശ്നം ഇവന്റുകൾ അല്ലെങ്കിൽ സന്ദേശങ്ങൾ കൈകാര്യം ചെയ്യുക എന്നതാണ്
ആസൂത്രണം ചെയ്യാത്ത ക്രമത്തിൽ എത്തിച്ചേരുന്നു. സന്ദേശങ്ങളുടെ ഒരു ശ്രേണി മാത്രമേ അയയ്‌ക്കുകയുള്ളൂവെന്ന് MPI ഉറപ്പുനൽകുന്നു
എ മുതൽ റാങ്ക് ബി വരെയുള്ള റാങ്കുകൾ അയച്ച ഉത്തരവിൽ വരും. എന്ന ക്രമത്തെക്കുറിച്ച് യാതൊരു ഉറപ്പുമില്ല
ഒരു മൂന്നാം റാങ്ക് C. In ൽ നിന്ന് B ലേക്ക് അയച്ച സന്ദേശങ്ങളുമായി ബന്ധപ്പെട്ട ആ സന്ദേശങ്ങളുടെ വരവ്
പ്രത്യേകിച്ചും, A ഒരു സന്ദേശം B ലേക്ക് അയയ്ക്കുന്നു, തുടർന്ന് A C ലേക്ക് ഒരു സന്ദേശം അയയ്ക്കുന്നു (അല്ലെങ്കിൽ പോലും കൈമാറുന്നു
സി ഉള്ള നിരവധി സന്ദേശങ്ങൾ) സി ഒരു സന്ദേശം ബിയിലേക്ക് അയക്കുന്നതിന് കാരണമാകുന്നു. സിയിൽ നിന്നുള്ള സന്ദേശം
A-ൽ നിന്നുള്ള സന്ദേശത്തിന് മുമ്പ് B-ൽ എത്തിയേക്കാം. ഇത് അനുവദിക്കാത്ത ഒരു MPI പ്രോഗ്രാം
സാധ്യതയ്ക്ക് "റേസ് അവസ്ഥ" എന്നൊരു ബഗ് ഉണ്ട്. റേസ് സാഹചര്യങ്ങൾ വളരെ സൂക്ഷ്മമായിരിക്കാം,
പ്രത്യേകിച്ചും പ്രക്രിയകളുടെ എണ്ണം വലുതായിരിക്കുമ്പോൾ.

അടിസ്ഥാന എംപി വ്യാഖ്യാനിച്ച ഇന്റർഫേസിൽ രണ്ട് വേരിയബിളുകൾ അടങ്ങിയിരിക്കുന്നു:
mp_size = പ്രക്രിയകളുടെ എണ്ണം
mp_rank = ഈ പ്രക്രിയയുടെ റാങ്കും നാല് ഫംഗ്ഷനുകളും:
mp_send, to, msg; // "ടു" എന്ന റാങ്കിലേക്ക് സന്ദേശമയയ്ക്കുക
msg = mp_recv(നിന്ന്); // "നിന്ന്" റാങ്കിൽ നിന്ന് സന്ദേശം സ്വീകരിക്കുക
റാങ്കുകൾ = mp_probe(ബ്ലോക്ക്); // തീർച്ചപ്പെടുത്താത്ത സന്ദേശങ്ങൾ അയയ്ക്കുന്നവരെ അന്വേഷിക്കുക
mp_exec, സ്ട്രിംഗ്; // എല്ലാ റാങ്കിലും സ്ട്രിംഗ് പാഴ്‌സ് ചെയ്‌ത് എക്‌സിക്യൂട്ട് ചെയ്യുക

ഒരു സമാന്തര ടാസ്‌ക് ആരംഭിക്കുന്നതിന് നിങ്ങൾ റാങ്ക് 0-ൽ mp_exec-ലേക്ക് വിളിക്കുക. പ്രധാന പ്രോഗ്രാം അങ്ങനെ സൃഷ്ടിച്ചപ്പോൾ
പൂർത്തിയാക്കുന്നു, റാങ്ക് 0 ഒഴികെയുള്ള എല്ലാ റാങ്കുകളും ഒരു നിഷ്ക്രിയ ലൂപ്പിലേക്ക് മടങ്ങുന്നു, അടുത്തതിനായി കാത്തിരിക്കുന്നു
mp_exec. റാങ്ക് 0 stdin-ൽ നിന്ന് അടുത്ത ഇൻപുട്ട് ലൈൻ എടുക്കുന്നു (അതായത്, അതിൽ ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു
ഒരു സംവേദനാത്മക സെഷനിൽ ആവശ്യപ്പെടുക), അല്ലെങ്കിൽ കൂടുതൽ ഇൻപുട്ട് ഇല്ലെങ്കിൽ എല്ലാ പ്രക്രിയകളും അവസാനിപ്പിക്കുന്നു
ഒരു ബാച്ച് സെഷനിൽ ലഭ്യമാണ്.

#include പാഴ്‌സർ നിർദ്ദേശവും ഉൾപ്പെടുന്നവയും യോറിക്ക് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്നത് എംപി പാക്കേജ് പരിഷ്‌ക്കരിക്കുന്നു.
കൂടാതെ ഫംഗ്ഷനുകൾ ആവശ്യമാണ്. അതായത്, ഒരു സമാന്തര ടാസ്ക് പ്രവർത്തിക്കുകയാണെങ്കിൽ (അതായത്, ഒരു ഫംഗ്ഷൻ ആരംഭിച്ചു
mp_exec വഴി), ഇവയെല്ലാം കൂട്ടായ പ്രവർത്തനങ്ങളായി മാറുന്നു. അതായത്, റാങ്ക് 0 മുഴുവൻ വായിക്കുന്നു
ഫയൽ ഉള്ളടക്കങ്ങൾ, ഒരു MPI സന്ദേശമായി മറ്റ് പ്രക്രിയകളിലേക്ക് ഉള്ളടക്കങ്ങൾ അയയ്ക്കുന്നു (ഇത് പോലെ
ഫയൽ ഉള്ളടക്കങ്ങളുടെ mp_exec). റാങ്ക് 0 ഒഴികെയുള്ള എല്ലാ പ്രക്രിയകളും ഈ സമയത്ത് മാത്രമേ പ്രവർത്തിക്കൂ
സമാന്തര ജോലികൾ; റാങ്ക് 0 മാത്രം പ്രവർത്തിക്കുമ്പോൾ ഒരു സമാന്തര ടാസ്ക്കിന് പുറത്ത് (മറ്റെല്ലാ റാങ്കുകളും
അടുത്ത mp_exec-നായി കാത്തിരിക്കുന്നു), #ഉൾക്കൊള്ളുന്ന നിർദ്ദേശവും ഉൾപ്പെടുത്തുന്നതും ആവശ്യമുള്ളതും
ഫംഗ്‌ഷനുകൾ അവയുടെ സാധാരണ സീരിയൽ പ്രവർത്തനത്തിലേക്ക് മടങ്ങുന്നു, ഇത് റാങ്ക് 0-നെ മാത്രം ബാധിക്കുന്നു.

mpy ആരംഭിക്കുമ്പോൾ, അത് സമാന്തര മോഡിലാണ്, അതിനാൽ എല്ലാ ഫയലുകളും yorick ഉൾക്കൊള്ളുന്നു
ആരംഭിക്കുന്നു (Y_SITE/i0 ലെ ഫയലുകൾ) കൂട്ടായ പ്രവർത്തനങ്ങളായി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഇതില്ലാതെ
ഫീച്ചർ, ഓരോ യോറിക് പ്രക്രിയയും ഫയലുകൾ ഉൾപ്പെടുന്ന സ്റ്റാർട്ടപ്പ് തുറക്കാനും വായിക്കാനും ശ്രമിക്കും,
എംപി എപ്പോഴെങ്കിലും ആരംഭിക്കുന്നതിന് മുമ്പ് ഫയൽ സിസ്റ്റം ഓവർലോഡ് ചെയ്യുന്നു. ഇവയുടെ ഉള്ളടക്കം കൈമാറുന്നു
ഓരോന്നിനും മതിയായ ബാൻഡ്‌വിഡ്ത്ത് ഉണ്ടെന്ന് ഉറപ്പാക്കാനുള്ള ഒരേയൊരു മാർഗ്ഗമാണ് MPI സന്ദേശങ്ങളായി ഫയലുകൾ
ഒരൊറ്റ ഫയലിന്റെ ഉള്ളടക്കം വായിക്കുന്നതിനുള്ള പ്രക്രിയ.

സ്റ്റാർട്ടപ്പിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന അവസാന ഫയൽ ഒന്നുകിൽ -batch ഓപ്ഷനിൽ വ്യക്തമാക്കിയ ഫയൽ ആണ്, അല്ലെങ്കിൽ
custom.i ഫയൽ. സുരക്ഷിതമല്ലാത്ത കസ്റ്റം.ഐയിലെ കോഡിലെ പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ
സമാന്തര നിർവ്വഹണം, mpy custom.i എന്നതിനായി നോക്കുന്നില്ല, പകരം custommp.i എന്നതിനാണ്. ദി
-ബാച്ച് ഫയലിലോ custommp.i-യിലോ ഉള്ള നിർദ്ദേശങ്ങൾ റാങ്ക് 0-ൽ സീരിയൽ മോഡിൽ നടപ്പിലാക്കുന്നു
മാത്രം. അതുപോലെ, mpy സാധാരണ process_argv ഫംഗ്‌ഷൻ അസാധുവാക്കുന്നു, അങ്ങനെ -i ഉം മറ്റുള്ളവയും
സീരിയൽ മോഡിൽ റാങ്ക് 0-ൽ മാത്രമേ കമാൻഡ് ലൈൻ ഓപ്ഷനുകൾ പ്രോസസ്സ് ചെയ്യൂ. ഇതിലെല്ലാം ഉദ്ദേശം
കേസുകൾ -ബാച്ച് അല്ലെങ്കിൽ custommp.i അല്ലെങ്കിൽ -i ഉൾപ്പെടുന്ന ഫയലുകൾ റാങ്ക് 0-ൽ മാത്രം എക്സിക്യൂട്ട് ചെയ്യുക എന്നതാണ്.
നിങ്ങൾ അവ അവിടെ ഇന്ററാക്ടീവ് ആയി ടൈപ്പ് ചെയ്തിരുന്നെങ്കിൽ. ഇവയിൽ ഏതിൽ നിന്നും mp_exec-ലേക്ക് വിളിക്കാൻ നിങ്ങൾക്ക് സ്വാതന്ത്ര്യമുണ്ട്
സമാന്തര ജോലികൾ ആരംഭിക്കുന്നതിനുള്ള ഫയലുകൾ, എന്നാൽ ഫയൽ തന്നെ സീരിയൽ ആണ്.

സാധാരണ സെറ്റിലേക്ക് ഒരു അധിക കമാൻഡ് ലൈൻ ഓപ്ഷൻ ചേർത്തിരിക്കുന്നു:
mpy -j somefile.i
എല്ലാ റാങ്കുകളിലും പാരലൽ മോഡിൽ somefile.i ഉൾപ്പെടുന്നു (വീണ്ടും, -i other.i ഉൾപ്പെടുന്നു other.i മാത്രം
സീരിയൽ മോഡിൽ റാങ്ക് 0-ൽ). ഒന്നിലധികം -j ഓപ്ഷനുകൾ ഉണ്ടെങ്കിൽ, സമാന്തരമായി സംഭവിക്കുന്നത് ഉൾപ്പെടുന്നു
കമാൻഡ് ലൈൻ ക്രമത്തിൽ. -j, -i ഓപ്‌ഷനുകൾ കൂടിച്ചേർന്നതാണെങ്കിൽ, എല്ലാ -j-ഉം സംഭവിക്കുന്നത് ഉൾപ്പെടുന്നു
ഏതിനും മുമ്പ് -i ഉൾപ്പെടുന്നു.

എംപിയിൽ ഫംഗ്‌ഷനുകൾ ഉൾപ്പെടുത്തുന്നതിന്റെ സങ്കീർണ്ണതയുടെ ഒരു പാർശ്വഫലമെന്ന നിലയിൽ, ഓട്ടോലോഡ് സവിശേഷതയാണ്
വികലാംഗൻ; നിങ്ങളുടെ കോഡ് യഥാർത്ഥത്തിൽ ഒരു ഓട്ടോലോഡഡ് ഫംഗ്‌ഷനെ വിളിച്ച് ഒരു ഉൾപ്പെടുത്തലിനെ ട്രിഗർ ചെയ്യുന്നുവെങ്കിൽ, mpy
ഒരു പിശകോടെ നിർത്തും. ഒരു സമാന്തരത്തിന് ആവശ്യമായ ഏതെങ്കിലും ഫംഗ്‌ഷനുകൾ നിങ്ങൾ വ്യക്തമായി ലോഡ് ചെയ്യണം
ഉപയോഗിക്കുന്ന ടാസ്‌ക്കുകൾക്ക് സമാന്തര ടാസ്‌ക്കിനുള്ളിൽ ഫംഗ്‌ഷൻ കോളുകൾ ആവശ്യമാണ്.

mp_send ഫംഗ്‌ഷന് ഏത് സംഖ്യാ യോറിക് അറേയും അയയ്‌ക്കാൻ കഴിയും (തരം char, short, int, long,
ഫ്ലോട്ട്, ഡബിൾ അല്ലെങ്കിൽ കോംപ്ലക്സ്), അല്ലെങ്കിൽ ഒരു സ്കെയിലർ സ്ട്രിംഗ് മൂല്യം. സന്ദേശം അയയ്ക്കുന്ന പ്രക്രിയ
MPI വഴി മൂലകങ്ങളുടെ എണ്ണം മാത്രം സംരക്ഷിക്കുന്നു, അതിനാൽ mp_recv ഒരു സ്കെയിലർ മൂല്യം മാത്രമേ ഉൽപ്പാദിപ്പിക്കുന്നുള്ളൂ അല്ലെങ്കിൽ
mp_send-ലേക്ക് എന്ത് ഡൈമൻഷണാലിറ്റി നൽകിയാലും മൂല്യങ്ങളുടെ ഒരു 1D ശ്രേണി.

നിങ്ങൾ ഉദ്ദേശിക്കുന്ന സന്ദേശം അയച്ചയാളെ വ്യക്തമാക്കാൻ mp_recv ഫംഗ്‌ഷൻ ആവശ്യപ്പെടുന്നു
സ്വീകരിക്കുക. അയച്ചയാളിൽ നിന്ന് ഒരു സന്ദേശം വരുന്നതുവരെ ഇത് തടയുന്നു, ഏതെങ്കിലും ക്യൂവിൽ
മറ്റ് അയക്കുന്നവരിൽ നിന്നുള്ള സന്ദേശങ്ങൾ മുൻകൂട്ടി എത്തിയേക്കാം. ക്യൂവിലുള്ള സന്ദേശങ്ങൾ ആയിരിക്കും
പൊരുത്തമുള്ള അയയ്‌ക്കുന്നയാൾക്കായി നിങ്ങൾ mp_recv-ലേക്ക് വിളിക്കുമ്പോൾ ലഭിച്ച ഓർഡർ അത് വീണ്ടെടുത്തു. ദി
ക്യൂയിംഗ് സവിശേഷത ഏറ്റവും ലളിതമായ റേസ് അവസ്ഥ ഒഴിവാക്കുന്നത് നാടകീയമായി എളുപ്പമാക്കുന്നു
നിങ്ങൾ വ്യാഖ്യാനിച്ച സമാന്തര പ്രോഗ്രാമുകൾ എഴുതുമ്പോൾ.

mp_probe ഫംഗ്‌ഷൻ ക്യൂവിലുള്ള സന്ദേശങ്ങൾ അയച്ച എല്ലാവരുടെയും ലിസ്റ്റ് നൽകുന്നു (അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ
ക്യൂ ശൂന്യമാണ്). വിളി mp_probe(0) ക്യൂ ശൂന്യമാണെങ്കിൽ പോലും ഉടനടി മടങ്ങാൻ.
വിളി mp_probe(1) ക്യൂ ശൂന്യമാണെങ്കിൽ തടയാൻ, ഒരു സന്ദേശമെങ്കിലും വരുമ്പോൾ മാത്രം മടങ്ങുക
mp_recv-ന് ലഭ്യമാണ്. വിളി mp_probe(2) ഒരു പുതിയ സന്ദേശം വരുന്നത് വരെ തടയാൻ, എങ്കിൽ പോലും
ചില സന്ദേശങ്ങൾ നിലവിൽ ലഭ്യമാണ്.

mp_exec ഫംഗ്‌ഷൻ ഒരു ലോഗരിഥമിക് ഫാൻഔട്ട് ഉപയോഗിക്കുന്നു - റാങ്ക് 0 ഓരോന്നിനും F പ്രോസസ്സുകളിലേക്ക് അയയ്ക്കുന്നു.
അത് F-ലേക്ക് കൂടുതൽ അയയ്‌ക്കുന്നു, എല്ലാ പ്രക്രിയകൾക്കും സന്ദേശം ലഭിക്കുന്നതുവരെ. ഒരിക്കൽ ഒരു പ്രക്രിയ
അതിന്റെ എല്ലാ അയയ്ക്കൽ പ്രവർത്തനങ്ങളും പൂർത്തിയാക്കുന്നു, അത് സന്ദേശത്തിന്റെ ഉള്ളടക്കങ്ങൾ പാഴ്‌സ് ചെയ്യുകയും നിർവ്വഹിക്കുകയും ചെയ്യുന്നു.
ഫാൻഔട്ട് അൽഗോരിതം N പ്രക്രിയകളിൽ N ഘട്ടങ്ങളുടെ അടിസ്ഥാന F ലേക്ക് ലോഗിൽ എത്തുന്നു. എഫ് പ്രക്രിയകൾ
റാങ്ക് 0 അയക്കുന്നത് 1, 2, 3, ..., എഫ് റാങ്കുകളാണ്. പൊതുവേ, റാങ്ക് r ഉള്ള പ്രക്രിയ ഇതിലേക്ക് അയയ്ക്കുന്നു
റാങ്കുകൾ r*F+1, r*F+2, ..., r*F+F (ഇവ N പ്രോസസ്സുകൾക്ക് N-1-നേക്കാൾ കുറവായിരിക്കുമ്പോൾ). ഈ സെറ്റ്
R റാങ്കിന്റെ "സ്റ്റാഫ്" എന്ന് വിളിക്കുന്നു. r>0 ഉള്ള റാങ്കുകൾക്ക് റാങ്ക് (r-1)/F-ൽ നിന്ന് സന്ദേശം ലഭിക്കും,
ആർ ന്റെ "ബോസ്" എന്ന് വിളിക്കപ്പെടുന്ന. mp_exec കോൾ mp_recv ക്യൂവിൽ പ്രവർത്തിക്കുന്നു;
മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു mp_exec ഫാൻഔട്ട് സമയത്ത് ബോസ് അല്ലാത്ത ഒരു റാങ്കിൽ നിന്നുള്ള സന്ദേശങ്ങൾ ആയിരിക്കും
mp_recv വഴി പിന്നീടുള്ള വീണ്ടെടുക്കലിനായി ക്യൂവിൽ. (ഈ സവിശേഷത കൂടാതെ, ഏതെങ്കിലും സമാന്തര ടാസ്‌ക്
ലോഗരിതമിക് ഫാൻഔട്ട് അല്ലാതെ മറ്റൊരു സന്ദേശ പാറ്റേൺ ഉപയോഗിച്ചത് റേസിനു വിധേയമാകും
വ്യവസ്ഥകൾ.)

ലോഗരിതമിക് ഫാൻഔട്ടും അതിന്റെ ആന്തരിക തുല്യതയും വളരെ ഉപയോഗപ്രദമാണ്, mpy ഒരു ജോഡി നൽകുന്നു
mp_exec പോലെയുള്ള ഫാനൗട്ട് പാറ്റേൺ ഉപയോഗിക്കുന്ന ഉയർന്ന തലത്തിലുള്ള ഫംഗ്‌ഷനുകൾ:
mp_handout, msg;
ആകെ = mp_handin (മൂല്യം);
mp_handout ഉപയോഗിക്കുന്നതിന്, റാങ്ക് 0 ഒരു msg കണക്കാക്കുന്നു, തുടർന്ന് എല്ലാ റാങ്കുകളും mp_handout എന്ന് വിളിക്കുന്നു, അത് msg അയയ്‌ക്കുന്നു
(0 ഒഴികെയുള്ള എല്ലാ റാങ്കുകളിലും ഒരു ഔട്ട്‌പുട്ട്) എല്ലായിടത്തും mp_exec-ന്റെ അതേ ഫാനൗട്ട്. ഉപയോഗിക്കാൻ
mp_handin, ഓരോ പ്രക്രിയയും മൂല്യം കണക്കാക്കുന്നു, തുടർന്ന് mp_handin എന്ന് വിളിക്കുന്നു, ഇത് തുകയുടെ തുക നൽകുന്നു
അവരുടെ സ്വന്തം മൂല്യവും അവരുടെ എല്ലാ സ്റ്റാഫും, അങ്ങനെ റാങ്ക് 0 mp_handin ന്റെ ആകെത്തുക നൽകുന്നു
ഓരോ പ്രക്രിയയിൽ നിന്നുമുള്ള മൂല്യങ്ങൾ.

ഒരു സിൻക്രൊണൈസേഷനായി പ്രവർത്തിക്കാൻ ആർഗ്യുമെന്റുകളില്ലാതെ നിങ്ങൾക്ക് mp_handin-നെ ഒരു ഫംഗ്‌ഷനായി വിളിക്കാം; എപ്പോൾ
അത്തരമൊരു കോളിന് ശേഷവും റാങ്ക് 0 തുടരുന്നു, മറ്റെല്ലാ റാങ്കുകളും ആ ഘട്ടത്തിൽ എത്തിയതായി നിങ്ങൾക്കറിയാം.
എല്ലാ സമാന്തര ടാസ്ക്കുകളും (mp_exec ഉപയോഗിച്ച് ആരംഭിക്കുന്ന എന്തും) mp_handin-ലേക്കുള്ള ഒരു കോളിലൂടെ പൂർത്തിയാക്കണം,
അല്ലെങ്കിൽ ടാസ്‌ക് ചെയ്യുമ്പോൾ എല്ലാ പ്രക്രിയകളും നിഷ്‌ക്രിയമായ അവസ്ഥയിലേക്ക് മടങ്ങിയെന്നതിന് തുല്യമായ ഗ്യാരണ്ടി
റാങ്ക് 0-ൽ അവസാനിക്കുന്നു.

mp_nfan ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഫാൻഔട്ട് പാരാമീറ്റർ എഫ് വീണ്ടെടുക്കാനോ മാറ്റാനോ കഴിയും. സ്ഥിരസ്ഥിതി
മൂല്യം 16 ആണ്, ഇത് വളരെ വലിയ പ്രക്രിയകൾക്ക് പോലും ന്യായമായതായിരിക്കണം.

ഒരു പ്രത്യേക സമാന്തര ടാസ്‌ക്കിനെ mp_connect എന്ന് വിളിക്കുന്നു, ഇത് നിങ്ങൾക്ക് വ്യാഖ്യാനിക്കാൻ ഉപയോഗിക്കാം
മറ്റെല്ലാ റാങ്കുകളും നിഷ്‌ക്രിയമായി ഇരിക്കുമ്പോൾ, ഏതെങ്കിലും ഒറ്റ-0 അല്ലാത്ത റാങ്കിലേക്കുള്ള കമാൻഡ് ലൈനുകൾ. റാങ്ക് 0 എയിൽ ഇരിക്കുന്നു
ലൂപ്പ് കീബോർഡ് വായിക്കുകയും വരികൾ "കണക്‌റ്റഡ്" റാങ്കിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു, അത് എക്സിക്യൂട്ട് ചെയ്യുന്നു
അവ, റാങ്ക് 0-ലേക്ക് തിരികെ ഒരു അംഗീകാരം അയയ്ക്കുന്നു. നിങ്ങൾ mp_disconnect ഫംഗ്‌ഷൻ പ്രവർത്തിപ്പിക്കുക
സമാന്തര ടാസ്ക്ക് പൂർത്തിയാക്കി റാങ്ക് 0 ലേക്ക് മടങ്ങുക.

അവസാനമായി, പിശക് വീണ്ടെടുക്കലിനെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്. ഒരു സമാന്തര ടാസ്ക്കിനിടെ ഒരു പിശക് സംഭവിച്ചാൽ,
mp_exec-ൽ നിന്ന് മനോഹരമായി പുറത്തുകടക്കാൻ mpy ശ്രമിക്കുന്നു, അങ്ങനെ റാങ്ക് 0 മടങ്ങുമ്പോൾ, മറ്റെല്ലാ റാങ്കുകളും
നിഷ്‌ക്രിയമാണ്, അടുത്ത mp_exec-ന് തയ്യാറാണ്. എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ഈ നടപടിക്രമം എന്നെന്നേക്കുമായി തൂങ്ങിക്കിടക്കും
പ്രക്രിയകളിലൊന്ന് അനന്തമായ ലൂപ്പിലാണ്, അല്ലെങ്കിൽ അത് ഒരിക്കലും സംഭവിക്കാത്ത അവസ്ഥയിലാണ്
mp_send, mp_recv, അല്ലെങ്കിൽ mp_probe എന്നിവയെ വിളിക്കുക, കാരണം MPI ഒരു സിഗ്നൽ അയയ്‌ക്കുന്നതിനുള്ള മാർഗങ്ങളൊന്നും നൽകുന്നില്ല
എല്ലാ പ്രക്രിയകളെയും തടസ്സപ്പെടുത്തുന്നു. (എംപിഐ എൻവയോൺമെന്റ് ഉള്ള ഒരു വഴിയാണിത്
"ക്രൂഡ്".) റാങ്ക് 0 പ്രോസസ്സ് റിപ്പോർട്ട് ചെയ്ത ആദ്യ പ്രക്രിയയുടെ റാങ്കിനൊപ്പം അവശേഷിക്കുന്നു a
തെറ്റ്, കൂടാതെ മറ്റൊരു കാരണത്താൽ തകരാറിലായ പ്രക്രിയകളുടെ എണ്ണവും
മറ്റൊരു റാങ്കിന് പിഴച്ചതായി സന്ദേശം അയച്ചു. ആദ്യത്തെ തകരാർ പ്രക്രിയ dbug-ൽ പ്രവേശിക്കാം
mp_connect വഴിയുള്ള മോഡ്; റാങ്ക് 0-ൽ സീരിയൽ മോഡിലേക്ക് മടങ്ങാൻ mp_disconnect അല്ലെങ്കിൽ dbexit ഉപയോഗിക്കുക.

ഓപ്ഷനുകൾ
-j file.i Yorick സോഴ്സ് ഫയൽ ഉൾപ്പെടുന്നു file.i mpy സമാന്തര മോഡിൽ ആരംഭിക്കുന്നത് പോലെ
എല്ലാ റാങ്കുകളിലും. ഇത് mpy ന് ശേഷമുള്ള mp_include ഫംഗ്‌ഷന് തുല്യമാണ്
ആരംഭിച്ചു.

-i file.i Yorick സോഴ്സ് ഫയൽ ഉൾപ്പെടുന്നു file.i mpy ആരംഭിക്കുന്നത് പോലെ, സീരിയൽ മോഡിൽ.
ഇത് mpy ആരംഭിച്ചതിന് ശേഷമുള്ള #include നിർദ്ദേശത്തിന് തുല്യമാണ്.

-ബാച്ച് file.i Yorick സോഴ്സ് ഫയൽ ഉൾപ്പെടുന്നു file.i mpy ആരംഭിക്കുന്നത് പോലെ, സീരിയൽ മോഡിൽ.
നിങ്ങളുടെ ഇഷ്‌ടാനുസൃതമാക്കൽ ഫയൽ custommp.i, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ അല്ല വായിക്കുക, എംപി ആണ്
ബാച്ച് മോഡിൽ സ്ഥാപിച്ചു. ബാച്ച് ഫംഗ്‌ഷനിൽ സഹായ കമാൻഡ് ഉപയോഗിക്കുക
(സഹായം, ബാച്ച്) ബാച്ച് മോഡിനെക്കുറിച്ച് കൂടുതലറിയാൻ. ബാച്ച് മോഡിൽ, എല്ലാം
പിശകുകൾ മാരകമാണ്; സാധാരണഗതിയിൽ, എംപി എക്സിക്യൂഷൻ നിർത്തി കൂടുതൽ കാത്തിരിക്കും
ഒരു പിശകിന് ശേഷം ഇൻപുട്ട്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് mpy.openmpi ഓൺലൈനായി ഉപയോഗിക്കുക