എംപിഐ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാമെന്നും ഇതിലേക്ക് കണക്റ്റുചെയ്യാമെന്നും ഈ കുറിപ്പ് കാണിക്കുന്നു വിഷ്വൽ സ്റ്റുഡിയോഎന്നിട്ട് കൂടെ ഉപയോഗിക്കുക നൽകിയിരിക്കുന്ന പാരാമീറ്ററുകൾ(കമ്പ്യൂട്ടിംഗ് നോഡുകളുടെ എണ്ണം). ഈ ലേഖനം വിഷ്വൽ സ്റ്റുഡിയോ 2015 ഉപയോഗിക്കുന്നു, കാരണം... ഇതാണ് എൻ്റെ വിദ്യാർത്ഥികൾക്ക് പ്രശ്‌നങ്ങളുണ്ടായത് (ഈ കുറിപ്പ് വിദ്യാർത്ഥികൾക്കായി എഴുതിയതാണ്), എന്നാൽ നിർദ്ദേശങ്ങൾ മറ്റ് പതിപ്പുകൾക്കും പ്രവർത്തിക്കും.

ഘട്ടം 1:
ഔദ്യോഗിക Microsoft വെബ്സൈറ്റിൽ ലഭ്യമായ HPC Pack 2008 SDK SP2 (നിങ്ങളുടെ കാര്യത്തിൽ ഇതിനകം മറ്റൊരു പതിപ്പ് ഉണ്ടായിരിക്കാം) നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യണം. പാക്കേജിൻ്റെയും സിസ്റ്റത്തിൻ്റെയും ബിറ്റ് ശേഷി പൊരുത്തപ്പെടണം.

ഘട്ടം 2:
നിങ്ങൾ പാതകൾ ക്രമീകരിക്കേണ്ടതുണ്ട്; ഇത് ചെയ്യുന്നതിന്, ഡീബഗ് - പ്രോപ്പർട്ടീസ് ടാബിലേക്ക് പോകുക:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\ഉൾക്കൊള്ളുക”

ലൈബ്രറി ഡയറക്ടറി ഫീൽഡിൽ:

"C:\Program Files\Microsoft HPC Pack 2008 SDK\Lib\amd64"

ലൈബ്രറികളുള്ള ഫീൽഡിൽ, 32 ചെലവാണെങ്കിൽ ബിറ്റ് പതിപ്പ്, amd64 ന് പകരം നിങ്ങൾ i386 രജിസ്റ്റർ ചെയ്യേണ്ടതുണ്ട്.

Msmpi.lib

:

ഘട്ടം 3:

ലോഞ്ച് കോൺഫിഗർ ചെയ്യുന്നതിന്, നിങ്ങൾ ഡീബഗ്ഗിംഗ് ടാബിലേക്ക് പോയി കമാൻഡ് ഫീൽഡിൽ വ്യക്തമാക്കേണ്ടതുണ്ട്:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\Bin\mpiexec.exe”

കമാൻഡ് ആർഗ്യുമെൻ്റ് ഫീൽഡിൽ, വ്യക്തമാക്കുക, ഉദാഹരണത്തിന്,

N 4 $(ടാർഗെറ്റ്പാത്ത്)

നമ്പർ 4 പ്രക്രിയകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു.

പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന് നിങ്ങൾ ലൈബ്രറി ബന്ധിപ്പിക്കേണ്ടതുണ്ട്

പദ്ധതിയിലേക്കുള്ള പാതയിൽ സിറിലിക് അടങ്ങിയിരിക്കരുത്. പിശകുകൾ സംഭവിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് Microsoft വെബ്സൈറ്റിൽ ലഭ്യമായ Microsoft MPI ഉപയോഗിക്കാം.

ഇത് ചെയ്യുന്നതിന്, ഇൻസ്റ്റാളേഷന് ശേഷം, ഡീബഗ്ഗിംഗ് ടാബിൻ്റെ കമാൻഡ് ഫീൽഡിൽ പാത്ത് നൽകുക:

"C:\Program Files\Microsoft MPI\Bin\mpiexec.exe"

കൂടാതെ, പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, അതിൻ്റെ ബിറ്റ് ഡെപ്ത് സൂചിപ്പിക്കാൻ മറക്കരുത്:

MPI ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഉദാഹരണം:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു; int main(int argc, char **argv) ( int rank, size; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); cout<< "The number of processes: " << size << " my number is " << rank << endl; MPI_Finalize(); return 0; }

2 നോഡുകളിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു:

വ്യാഖ്യാനം: വിതരണം ചെയ്ത മെമ്മറി സിസ്റ്റങ്ങൾക്കുള്ള സമാന്തര പ്രോഗ്രാമിംഗ് സ്റ്റാൻഡേർഡായി MPI സാങ്കേതികവിദ്യയെ പരിഗണിക്കുന്നതിനാണ് പ്രഭാഷണം നീക്കിവച്ചിരിക്കുന്നത്. ഡാറ്റാ ട്രാൻസ്മിഷൻ്റെ പ്രധാന മോഡുകൾ പരിഗണിക്കുന്നു. പ്രോസസ് ഗ്രൂപ്പുകൾ, ആശയവിനിമയക്കാർ തുടങ്ങിയ ആശയങ്ങൾ അവതരിപ്പിക്കപ്പെടുന്നു. അടിസ്ഥാന ഡാറ്റ തരങ്ങൾ, പോയിൻ്റ്-ടു-പോയിൻ്റ് പ്രവർത്തനങ്ങൾ, കൂട്ടായ പ്രവർത്തനങ്ങൾ, സമന്വയ പ്രവർത്തനങ്ങൾ, സമയ അളവുകൾ എന്നിവ ഉൾക്കൊള്ളുന്നു.

പ്രഭാഷണത്തിൻ്റെ ഉദ്ദേശ്യം:സമാന്തര അൽഗോരിതങ്ങൾ വികസിപ്പിക്കുന്നതിനുള്ള പൊതു രീതിശാസ്ത്രം പഠിക്കുന്നതിനാണ് പ്രഭാഷണം ലക്ഷ്യമിടുന്നത്.

പ്രഭാഷണത്തിൻ്റെ വീഡിയോ റെക്കോർഡിംഗ് - (വോളിയം - 134 MB).

5.1 MPI: അടിസ്ഥാന ആശയങ്ങളും നിർവചനങ്ങളും

MPI മാനദണ്ഡത്തിന് അടിസ്ഥാനമായ നിരവധി ആശയങ്ങളും നിർവചനങ്ങളും നമുക്ക് പരിഗണിക്കാം.

5.1.1. ഒരു സമാന്തര പ്രോഗ്രാമിൻ്റെ ആശയം

താഴെ സമാന്തര പ്രോഗ്രാം MPI-യുടെ ചട്ടക്കൂടിനുള്ളിൽ, ഒരേസമയം നടപ്പിലാക്കുന്ന ഒരു കൂട്ടം ഞങ്ങൾ മനസ്സിലാക്കുന്നു പ്രക്രിയകൾ. വ്യത്യസ്‌ത പ്രോസസറുകളിൽ പ്രോസസ്സുകൾ എക്‌സിക്യൂട്ട് ചെയ്യാൻ കഴിയും, എന്നാൽ ഒരേ പ്രോസസറിൽ നിരവധി പ്രോസസുകൾ സ്ഥാപിക്കാനും കഴിയും (ഈ സാഹചര്യത്തിൽ, അവ സമയ-പങ്കിടൽ മോഡിൽ നടപ്പിലാക്കുന്നു). അങ്ങേയറ്റത്തെ സാഹചര്യത്തിൽ, ഒരു സമാന്തര പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യാൻ ഒരൊറ്റ പ്രോസസർ ഉപയോഗിക്കാം - ഒരു ചട്ടം പോലെ, സമാന്തര പ്രോഗ്രാമിൻ്റെ കൃത്യത പരിശോധിക്കാൻ ഈ രീതി ഉപയോഗിക്കുന്നു.

ഒരു സമാന്തര പ്രോഗ്രാമിൻ്റെ ഓരോ പ്രക്രിയയും ഒരേ പ്രോഗ്രാം കോഡിൻ്റെ പകർപ്പിൽ നിന്നാണ് ( SPMP മോഡൽ). ഒരു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമിൻ്റെ രൂപത്തിൽ അവതരിപ്പിച്ചിരിക്കുന്ന ഈ പ്രോഗ്രാം കോഡ്, ഉപയോഗിക്കുന്ന എല്ലാ പ്രോസസറുകളിലും സമാന്തര പ്രോഗ്രാം സമാരംഭിക്കുന്ന സമയത്ത് ലഭ്യമായിരിക്കണം. എംപിഐ ലൈബ്രറിയുടെ ഒന്നോ അതിലധികമോ നടപ്പിലാക്കൽ ഉപയോഗിച്ച് എക്‌സിക്യൂട്ടബിൾ പ്രോഗ്രാമിൻ്റെ സോഴ്‌സ് കോഡ് സി അല്ലെങ്കിൽ ഫോർട്രാൻ അൽഗോരിതം ഭാഷകളിൽ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്.

എംപിഐ പ്രോഗ്രാം എക്‌സിക്യൂഷൻ എൻവയോൺമെൻ്റ് ഉപയോഗിച്ച് സമാന്തര പ്രോഗ്രാം സമാരംഭിക്കുന്ന സമയത്ത് പ്രോസസ്സുകളുടെ എണ്ണവും ഉപയോഗിച്ച പ്രോസസ്സറുകളുടെ എണ്ണവും നിർണ്ണയിക്കപ്പെടുന്നു, കൂടാതെ കണക്കുകൂട്ടലുകൾക്കിടയിൽ മാറ്റാൻ കഴിയില്ല (പ്രോസസുകളുടെ എണ്ണം ചലനാത്മകമായി മാറ്റാനുള്ള സാധ്യത MPI-2 സ്റ്റാൻഡേർഡ് നൽകുന്നു). എല്ലാ പ്രോഗ്രാം പ്രക്രിയകളും 0 മുതൽ തുടർച്ചയായി അക്കമിട്ടിരിക്കുന്നു p-1, എവിടെ പിപ്രക്രിയകളുടെ ആകെ എണ്ണമാണ്. പ്രോസസ്സ് നമ്പർ വിളിക്കുന്നു റാങ്ക്പ്രക്രിയ.

5.1.2. ഡാറ്റ കൈമാറ്റ പ്രവർത്തനങ്ങൾ

എംപിഐ സന്ദേശം കൈമാറുന്ന പ്രവർത്തനങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. MPI-യുടെ ഭാഗമായി നൽകിയിരിക്കുന്ന ഫംഗ്ഷനുകളിൽ, വ്യത്യസ്തമായവയുണ്ട് ഇരട്ടിക്കുന്നു (പോയിൻ്റ്-ടു-പോയിൻ്റ്) രണ്ട് പ്രക്രിയകൾക്കിടയിലുള്ള പ്രവർത്തനങ്ങൾ കൂടാതെ കൂട്ടായ (കൂട്ടായ) നിരവധി പ്രക്രിയകളുടെ ഒരേസമയം ഇടപെടുന്നതിനുള്ള ആശയവിനിമയ പ്രവർത്തനങ്ങൾ.

ജോടിയാക്കിയ പ്രവർത്തനങ്ങൾ നടത്താൻ, സിൻക്രണസ്, ബ്ലോക്ക് ചെയ്യൽ മുതലായവ ഉൾപ്പെടെ വിവിധ ട്രാൻസ്മിഷൻ മോഡുകൾ ഉപയോഗിക്കാം - സാധ്യമായതിൻ്റെ പൂർണ്ണമായ പരിഗണന ട്രാൻസ്മിഷൻ മോഡുകൾഉപവിഭാഗം 5.3-ൽ നിർവ്വഹിക്കും.

നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, മിക്ക അടിസ്ഥാന കൂട്ടായ ഡാറ്റാ ട്രാൻസ്ഫർ പ്രവർത്തനങ്ങളും നടപ്പിലാക്കേണ്ടതിൻ്റെ ആവശ്യകത MPI സ്റ്റാൻഡേർഡ് നൽകുന്നു - ഉപവിഭാഗങ്ങൾ 5.2, 5.4 കാണുക.

5.1.3. ആശയവിനിമയക്കാരുടെ ആശയം

ഒരു സമാന്തര പ്രോഗ്രാമിൻ്റെ പ്രക്രിയകൾ സംയോജിപ്പിച്ചിരിക്കുന്നു ഗ്രൂപ്പുകൾ. താഴെ ആശയവിനിമയക്കാരൻ MPI എന്നത് ഒരു കൂട്ടം പ്രക്രിയകളും നിരവധി അധിക പാരാമീറ്ററുകളും സംയോജിപ്പിച്ച് പ്രത്യേകം സൃഷ്ടിച്ച ഒരു സേവന വസ്തുവിനെ സൂചിപ്പിക്കുന്നു ( സന്ദർഭം) ഡാറ്റ കൈമാറ്റ പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ ഉപയോഗിക്കുന്നു.

സാധാരണഗതിയിൽ, ജോടിയാക്കിയ ഡാറ്റാ ട്രാൻസ്ഫർ പ്രവർത്തനങ്ങൾ ഒരേ കമ്മ്യൂണിക്കേറ്ററുടേതായ പ്രക്രിയകൾക്കായി നടത്തുന്നു. എല്ലാ ആശയവിനിമയ പ്രക്രിയകൾക്കും ഒരേസമയം കൂട്ടായ പ്രവർത്തനങ്ങൾ പ്രയോഗിക്കുന്നു. തൽഫലമായി, MPI-യിലെ ഡാറ്റാ കൈമാറ്റ പ്രവർത്തനങ്ങൾക്ക് ഉപയോഗിക്കേണ്ട കമ്മ്യൂണിക്കേറ്റർ വ്യക്തമാക്കുന്നത് നിർബന്ധമാണ്.

കണക്കുകൂട്ടലുകൾക്കിടയിൽ, പുതിയ പ്രോസസ് ഗ്രൂപ്പുകളും കമ്മ്യൂണിക്കേറ്ററുകളും സൃഷ്ടിക്കാനും നിലവിലുള്ള പ്രോസസ് ഗ്രൂപ്പുകളും ആശയവിനിമയങ്ങളും ഇല്ലാതാക്കാനും കഴിയും. ഒരേ പ്രക്രിയ വ്യത്യസ്ത ഗ്രൂപ്പുകൾക്കും ആശയവിനിമയക്കാർക്കും ഉൾപ്പെടാം. സമാന്തര പ്രോഗ്രാമിൽ നിലവിലുള്ള എല്ലാ പ്രക്രിയകളും MPI_COMM_WORLD എന്ന ഐഡൻ്റിഫയർ ഉപയോഗിച്ച് സ്ഥിരസ്ഥിതിയായി സൃഷ്ടിച്ച കമ്മ്യൂണിക്കേറ്ററിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

വ്യത്യസ്ത ഗ്രൂപ്പുകളിൽ നിന്നുള്ള പ്രക്രിയകൾക്കിടയിൽ ഡാറ്റ കൈമാറേണ്ടത് ആവശ്യമാണെങ്കിൽ, ഒരു ആഗോള ആശയവിനിമയം സൃഷ്ടിക്കേണ്ടത് ആവശ്യമാണ് ( ആശയവിനിമയക്കാരൻ).

ഗ്രൂപ്പുകളുമായും ആശയവിനിമയക്കാരുമായും പ്രവർത്തിക്കുന്നതിനുള്ള MPI-യുടെ കഴിവുകളെക്കുറിച്ചുള്ള വിശദമായ ചർച്ച ഉപവിഭാഗം 5.6-ൽ നടത്തും.

5.1.4. ഡാറ്റ തരങ്ങൾ

സന്ദേശം കൈമാറുന്ന പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, MPI ഫംഗ്‌ഷനുകളിൽ അയയ്‌ക്കാനോ സ്വീകരിക്കാനോ ഉള്ള ഡാറ്റ നിങ്ങൾ വ്യക്തമാക്കണം. തരംഡാറ്റ അയച്ചു. MPI-യിൽ ഒരു വലിയ സെറ്റ് അടങ്ങിയിരിക്കുന്നു അടിസ്ഥാന തരങ്ങൾസി, ഫോർട്രാൻ എന്നീ അൽഗോരിതമിക് ഭാഷകളിലെ ഡാറ്റാ തരങ്ങളുമായി വലിയ തോതിൽ യോജിക്കുന്ന ഡാറ്റ. കൂടാതെ, എംപിഐക്ക് പുതിയത് സൃഷ്ടിക്കാനുള്ള കഴിവുണ്ട് ഉരുത്തിരിഞ്ഞ തരങ്ങൾഫോർവേഡ് ചെയ്ത സന്ദേശങ്ങളുടെ ഉള്ളടക്കത്തിൻ്റെ കൂടുതൽ കൃത്യവും സംക്ഷിപ്തവുമായ വിവരണത്തിനുള്ള ഡാറ്റ.

ലഭിച്ച ഡാറ്റ തരങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള MPI-യുടെ കഴിവുകളെക്കുറിച്ചുള്ള വിശദമായ ചർച്ച ഉപവിഭാഗം 5.5-ൽ നടത്തും.

5.1.5. വെർച്വൽ ടോപ്പോളജികൾ

നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, ഒരേ ആശയവിനിമയക്കാരൻ്റെ ഏതെങ്കിലും പ്രക്രിയകൾക്കിടയിൽ ജോടിയാക്കിയ ഡാറ്റ കൈമാറ്റ പ്രവർത്തനങ്ങൾ നടത്താം, കൂടാതെ ആശയവിനിമയത്തിൻ്റെ എല്ലാ പ്രക്രിയകളും ഒരു കൂട്ടായ പ്രവർത്തനത്തിൽ പങ്കെടുക്കുന്നു. ഇക്കാര്യത്തിൽ, പ്രക്രിയകൾക്കിടയിലുള്ള ആശയവിനിമയ ലൈനുകളുടെ ലോജിക്കൽ ടോപ്പോളജിക്ക് ഒരു സമ്പൂർണ്ണ ഗ്രാഫിൻ്റെ ഘടനയുണ്ട് (പ്രോസസറുകൾക്കിടയിൽ യഥാർത്ഥ ഫിസിക്കൽ കമ്മ്യൂണിക്കേഷൻ ചാനലുകളുടെ സാന്നിധ്യം കണക്കിലെടുക്കാതെ).

അതേ സമയം (ഇത് ഇതിനകം സെക്ഷൻ 3 ൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്), നിരവധി സമാന്തര അൽഗോരിതങ്ങളുടെ അവതരണത്തിനും തുടർന്നുള്ള വിശകലനത്തിനും, ചില ടോപ്പോളജികളുടെ രൂപത്തിൽ നിലവിലുള്ള ആശയവിനിമയ ശൃംഖലയുടെ ലോജിക്കൽ പ്രാതിനിധ്യം ഉണ്ടായിരിക്കുന്നതാണ് ഉചിതം.

ഫോമിൽ ഒന്നിലധികം പ്രക്രിയകളെ പ്രതിനിധീകരിക്കാനുള്ള കഴിവ് MPI- യ്ക്ക് ഉണ്ട് ഗ്രേറ്റിംഗ്സ്അനിയന്ത്രിതമായ അളവ് (ഉപവിഭാഗം 5.7 കാണുക). ഈ സാഹചര്യത്തിൽ, ലാറ്റിസുകളുടെ അതിർത്തി പ്രക്രിയകൾ അയൽപക്കമായി പ്രഖ്യാപിക്കാം, അതുവഴി, ലാറ്റിസുകളെ അടിസ്ഥാനമാക്കി, തരം ഘടനകൾ ടോറസ്.

കൂടാതെ, ആവശ്യമായ ഏതെങ്കിലും തരത്തിലുള്ള ലോജിക്കൽ (വെർച്വൽ) ടോപ്പോളജികൾ സൃഷ്ടിക്കുന്നതിനുള്ള ടൂളുകൾ MPI-യിൽ ഉണ്ട്. ടോപ്പോളജികളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള MPI-യുടെ കഴിവുകളെക്കുറിച്ചുള്ള വിശദമായ ചർച്ച ഉപവിഭാഗം 5.7-ൽ നടത്തും.

അവസാനമായി, MPI നോക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ് അവസാനത്തെ ഒരു കൂട്ടം കുറിപ്പുകൾ:

• പ്രവർത്തനങ്ങളുടെ വിവരണങ്ങളും നൽകിയിരിക്കുന്ന പ്രോഗ്രാമുകളുടെ എല്ലാ ഉദാഹരണങ്ങളും അൽഗോരിതമിക് ഭാഷയിൽ അവതരിപ്പിക്കും; ഫോർട്രാൻ എന്ന അൽഗോരിതം ഭാഷയ്‌ക്കായി MPI ഉപയോഗിക്കുന്നതിൻ്റെ സവിശേഷതകൾ വിഭാഗം 5.8.1-ൽ നൽകും.
• MPI ലൈബ്രറികളുടെ ലഭ്യമായ നിർവ്വഹണങ്ങളുടെ ഒരു സംക്ഷിപ്ത വിവരണവും MPI പ്രോഗ്രാമുകളുടെ നിർവ്വഹണ പരിസ്ഥിതിയുടെ പൊതുവായ വിവരണവും വിഭാഗം 5.8.2-ൽ ചർച്ച ചെയ്യും.
• MPI കഴിവുകളുടെ പ്രധാന അവതരണം പതിപ്പ് 1.2 സ്റ്റാൻഡേർഡിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും ( MPI-1); പതിപ്പ് 2.0 സ്റ്റാൻഡേർഡിൻ്റെ അധിക പ്രോപ്പർട്ടികൾ ക്ലോസ് 5.8.3 ൽ അവതരിപ്പിക്കും.

എംപിഐ പഠിക്കാൻ തുടങ്ങുമ്പോൾ, ഒരു വശത്ത്, എംപിഐ തികച്ചും സങ്കീർണ്ണമാണെന്ന് ശ്രദ്ധിക്കാം - എംപിഐ സ്റ്റാൻഡേർഡ് 125 ലധികം ഫംഗ്ഷനുകളുടെ സാന്നിധ്യം നൽകുന്നു. മറുവശത്ത്, MPI യുടെ ഘടന ശ്രദ്ധാപൂർവ്വം ചിന്തിക്കുന്നു - 6 MPI ഫംഗ്ഷനുകൾ മാത്രം പരിഗണിച്ച ശേഷം സമാന്തര പ്രോഗ്രാമുകളുടെ വികസനം ആരംഭിക്കാം. വികസിപ്പിച്ച അൽഗോരിതങ്ങളുടെയും പ്രോഗ്രാമുകളുടെയും സങ്കീർണ്ണത വർദ്ധിക്കുന്നതിനനുസരിച്ച് MPI-യുടെ എല്ലാ അധിക സവിശേഷതകളും മാസ്റ്റർ ചെയ്യാൻ കഴിയും. ഈ ശൈലിയിലാണ് - ലളിതം മുതൽ സങ്കീർണ്ണമായത് വരെ - MPI-യിലെ എല്ലാ വിദ്യാഭ്യാസ സാമഗ്രികളും കൂടുതൽ അവതരിപ്പിക്കപ്പെടും.

5.2 MPI ഉപയോഗിച്ച് സമാന്തര പ്രോഗ്രാം വികസനം ആമുഖം

5.2.1. MPI അടിസ്ഥാനങ്ങൾ

ലളിതമായ സമാന്തര പ്രോഗ്രാമുകളുടെ വികസനത്തിന് ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ MPI ഫംഗ്‌ഷനുകൾ നമുക്ക് അവതരിപ്പിക്കാം.

5.2.1.1 MPI പ്രോഗ്രാമുകളുടെ തുടക്കവും അവസാനിപ്പിക്കലും

ആദ്യത്തെ ഫംഗ്‌ഷൻ വിളിച്ചു MPI ഒരു ഫംഗ്‌ഷൻ ആയിരിക്കണം:

int MPI_Init (int *agrc, char ***argv);

MPI പ്രോഗ്രാം എക്സിക്യൂഷൻ എൻവയോൺമെൻ്റ് ആരംഭിക്കുന്നതിന്. കമാൻഡ് ലൈനിലെ ആർഗ്യുമെൻ്റുകളുടെ എണ്ണവും കമാൻഡ് ലൈനിൻ്റെ തന്നെ വാചകവുമാണ് ഫംഗ്ഷൻ പാരാമീറ്ററുകൾ.

അവസാനത്തെ ഫംഗ്‌ഷൻ വിളിച്ചു MPI ഒരു ഫംഗ്‌ഷൻ ആയിരിക്കണം:

int MPI_Finalize(അസാധു);

തൽഫലമായി, MPI ഉപയോഗിച്ച് വികസിപ്പിച്ച ഒരു സമാന്തര പ്രോഗ്രാമിൻ്റെ ഘടനയ്ക്ക് ഇനിപ്പറയുന്ന ഫോം ഉണ്ടായിരിക്കണം എന്നത് ശ്രദ്ധിക്കാവുന്നതാണ്:

#ഉൾപ്പെടുത്തുക "mpi.h" int main (int argc, char *argv) (<программный код без использования MPI функций>MPI_Init(&agrc, &argv);<программный код с использованием MPI функций>MPI_Finalize();<программный код без использования MPI функций>തിരികെ 0; )

ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്:

1. ഫയൽ mpi.h MPI ലൈബ്രറിയുടെ പേരുള്ള സ്ഥിരാങ്കങ്ങൾ, ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പുകൾ, ഡാറ്റ തരങ്ങൾ എന്നിവയുടെ നിർവചനങ്ങൾ അടങ്ങിയിരിക്കുന്നു,
2. പ്രവർത്തനങ്ങൾ MPI_Initഒപ്പം MPI_Finalizeനിർബന്ധിതവും സമാന്തര പ്രോഗ്രാമിൻ്റെ ഓരോ പ്രക്രിയയിലൂടെയും (ഒരിക്കൽ മാത്രം) നടപ്പിലാക്കണം,
3. വിളിക്കുന്നതിന് മുമ്പ് MPI_Initഫംഗ്ഷൻ ഉപയോഗിക്കാം MPI_Initializedമുമ്പ് ഒരു കോൾ ചെയ്തിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ MPI_Init.

മുകളിൽ ചർച്ച ചെയ്ത ഫംഗ്‌ഷനുകളുടെ ഉദാഹരണങ്ങൾ MPI-യിലെ ഫംഗ്‌ഷനുകൾക്ക് പേരിടുന്നതിനുള്ള വാക്യഘടനയെക്കുറിച്ചുള്ള ഒരു ആശയം നൽകുന്നു. ഫംഗ്‌ഷൻ നാമത്തിന് മുമ്പായി MPI പ്രിഫിക്‌സും, തുടർന്ന് പേരിൻ്റെ ഒന്നോ അതിലധികമോ പദങ്ങളും ഉണ്ടായിരിക്കും, ഫംഗ്‌ഷൻ നാമത്തിൻ്റെ ആദ്യ വാക്ക് ഒരു വലിയ പ്രതീകത്തിൽ ആരംഭിക്കുന്നു, കൂടാതെ വാക്കുകൾ ഒരു അടിവരയിട്ട് വേർതിരിക്കുന്നു. MPI ഫംഗ്ഷനുകളുടെ പേരുകൾ, ഒരു ചട്ടം പോലെ, ഫംഗ്ഷൻ നടത്തുന്ന പ്രവർത്തനങ്ങളുടെ ഉദ്ദേശ്യം വിശദീകരിക്കുന്നു.

ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്:

• കമ്മ്യൂണിക്കേറ്റർ MPI_COMM_WORLD, നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, സ്വതവേ സൃഷ്‌ടിക്കുകയും സമാന്തര പ്രോഗ്രാമിൻ്റെ എല്ലാ പ്രക്രിയകളെയും പ്രതിനിധീകരിക്കുകയും ചെയ്യുന്നു,
• ഫംഗ്ഷൻ ഉപയോഗിച്ച് ലഭിച്ച റാങ്ക് MPI_Comm_rank, ഈ ഫംഗ്‌ഷനിലേക്ക് കോൾ ചെയ്‌ത പ്രോസസ്സിൻ്റെ റാങ്കാണ്, അതായത്. വേരിയബിൾ പ്രോക് റാങ്ക്വ്യത്യസ്ത പ്രക്രിയകളിൽ വ്യത്യസ്ത മൂല്യങ്ങൾ എടുക്കും.

MPI പ്രവർത്തനങ്ങൾ

ഉരുത്തിരിഞ്ഞ തരം, പ്രവർത്തനങ്ങൾ, ഡാറ്റ തരങ്ങൾ

Bsend Buffer_attach Get_count ANY_SOURCE Sendrecv_replace ANY_TAG അന്വേഷണം

Allgetherv Alltoall Alltoallv Rduce_scatter സ്കാൻ കുറയ്ക്കുക

പ്രത്യേക കൺസ്ട്രക്റ്റർ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട എംപിഐ തരങ്ങളിൽ നിന്നും മുമ്പ് നിർവചിക്കപ്പെട്ട ഡിറൈവ്ഡ് തരങ്ങളിൽ നിന്നും ഒരു ഉരുത്തിരിഞ്ഞ തരം നിർമ്മിക്കപ്പെടുന്നു.

MPI_Type_contiguous, MPI_Type_vector, MPI_Type_hvector, MPI_Type_indexed, MPI_Type_hindexed, MPI_Type_struct.

MPI_Type_commit ഫംഗ്‌ഷനിൽ വിളിച്ച് ഒരു പുതിയ തരം റജിസ്റ്റർ ചെയ്തു. രജിസ്ട്രേഷന് ശേഷം മാത്രമേ ആശയവിനിമയ ദിനചര്യകളിലും മറ്റ് തരങ്ങളുടെ നിർമ്മാണത്തിലും ഒരു പുതിയ തരം ഉപയോഗിക്കാനാകൂ. മുൻകൂട്ടി നിശ്ചയിച്ച MPI തരങ്ങൾ രജിസ്റ്റർ ചെയ്തതായി കണക്കാക്കുന്നു.

ഒരു ഉരുത്തിരിഞ്ഞ തരം ഇനി ആവശ്യമില്ലെങ്കിൽ, MPI_Type_free ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് അത് നശിപ്പിക്കപ്പെടും.

1) MPI_Init - ഇനീഷ്യലൈസേഷൻ ഫംഗ്‌ഷൻ. ഈ ഫംഗ്‌ഷൻ എക്‌സിക്യൂഷൻ ചെയ്യുന്നതിൻ്റെ ഫലമായി, എല്ലാ ആപ്ലിക്കേഷൻ പ്രോസസുകളും സ്ഥാപിക്കുന്ന ഒരു പ്രോസസ് ഗ്രൂപ്പ് സൃഷ്‌ടിക്കുന്നു, കൂടാതെ ഒരു കമ്മ്യൂണിക്കേഷൻ ഏരിയ സൃഷ്‌ടിക്കുന്നു, ഇത് മുൻനിർവചിക്കപ്പെട്ട കമ്മ്യൂണിക്കേറ്റർ MPI_COMM_WORLD വിവരിക്കുന്നു.

MPI_Type_commit - തരം രജിസ്ട്രേഷൻ, MPI_Type_free - തരം നാശം

int MPI_Init(int *argc, char ***argv);

2) MPI_Finalize - MPI പ്രോഗ്രാമുകൾ പൂർത്തിയാക്കുന്നതിനുള്ള പ്രവർത്തനം. ഫംഗ്ഷൻ എല്ലാ MPI പ്രക്രിയകളും അടയ്ക്കുകയും എല്ലാ ആശയവിനിമയ മേഖലകളും ഇല്ലാതാക്കുകയും ചെയ്യുന്നു.

int MPI_Finalize(അസാധു);

3) ആശയവിനിമയ മേഖലയിലെ പ്രക്രിയകളുടെ എണ്ണം നിർണ്ണയിക്കുന്നതിനുള്ള പ്രവർത്തനം MPI_Comm_size . കമ്മ്യൂണിക്കേറ്റർ കോമിൻ്റെ ആശയവിനിമയ മേഖലയിലെ പ്രക്രിയകളുടെ എണ്ണം ഫംഗ്ഷൻ നൽകുന്നു.

int MPI_Comm_size(MPI_Comm comm, int *size);

4) പ്രോസസ്സ് നമ്പർ കണ്ടെത്തൽ പ്രവർത്തനം MPI_Comm_rank . ഈ ഫംഗ്‌ഷൻ എന്ന് വിളിക്കുന്ന പ്രക്രിയയുടെ എണ്ണം ഫംഗ്ഷൻ നൽകുന്നു. പ്രോസസ്സ് നമ്പറുകൾ 0..size-1 എന്ന ശ്രേണിയിലാണ്.

int MPI_Comm_rank(MPI_Comm comm, int *rank);

5) സന്ദേശ പ്രവർത്തനം MPI_അയയ്ക്കുക. കമ്മ്യൂണിക്കേറ്റർ കോമിൻ്റെ കമ്മ്യൂണിക്കേഷൻ ഏരിയയിൽ ഡെസ്‌റ്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് ഐഡൻ്റിഫയർ ടാഗോടുകൂടിയ സന്ദേശ ഡാറ്റാ ടൈപ്പിൻ്റെ കൗണ്ട് ഘടകങ്ങൾ ഫംഗ്ഷൻ അയയ്ക്കുന്നു.

int MPI_Send (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm);

6) സന്ദേശ സ്വീകരണ പ്രവർത്തനം MPI_Recv. കമ്മ്യൂണിക്കേറ്റർ കമ്മ്യൂണിക്കേഷൻ ഏരിയയിലെ സോഴ്‌സ് പ്രോസസ്സിൽ നിന്ന് ഐഡൻ്റിഫയർ ടാഗോടുകൂടിയ സന്ദേശ ഡാറ്റാ ടൈപ്പിൻ്റെ കൗണ്ട് ഘടകങ്ങൾ ഫംഗ്ഷന് സ്വീകരിക്കുന്നു.

int MPI_Recv(അസാധുവായ* buf, int count, MPI_Datatype ഡാറ്റാടൈപ്പ്, int source, int tag, MPI_Comm comm, MPI_Status *status)

7) ടൈമിംഗ് ഫംഗ്‌ഷൻ (ടൈമർ) MPI_Wtime. ഫംഗ്ഷൻ, ഭൂതകാലത്തിലെ ചില പോയിൻ്റ് (റഫറൻസ് പോയിൻ്റ്) മുതൽ കടന്നുപോയ ജ്യോതിശാസ്ത്ര സമയം സെക്കൻഡിൽ നൽകുന്നു.

ഇരട്ട MPI_Wtime(അസാധു)

പ്രക്രിയകൾക്കിടയിൽ സന്ദേശങ്ങൾ കൈമാറുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ ഇവയായി തിരിച്ചിരിക്കുന്നു:

പ്രിഫിക്സ് എസ് (സിൻക്രണസ്)

സിൻക്രണസ് ഡാറ്റ ട്രാൻസ്ഫർ മോഡ് എന്നാണ് അർത്ഥമാക്കുന്നത്. ഡാറ്റ സ്വീകരണം അവസാനിക്കുമ്പോൾ മാത്രമേ ഡാറ്റാ ട്രാൻസ്മിഷൻ പ്രവർത്തനം അവസാനിക്കുകയുള്ളൂ. പ്രവർത്തനം പ്രാദേശികമല്ലാത്തതാണ്.

പ്രിഫിക്‌സ് ബി (ബഫർ ചെയ്‌തത്)

ബഫർ ചെയ്ത ഡാറ്റ ട്രാൻസ്ഫർ മോഡ് എന്നാണ് അർത്ഥമാക്കുന്നത്. എക്സ്ചേഞ്ച് പ്രവർത്തനങ്ങളിൽ ഉപയോഗിക്കുന്ന ഒരു പ്രത്യേക ഫംഗ്ഷൻ ഉപയോഗിച്ച് അയയ്ക്കൽ പ്രക്രിയയുടെ വിലാസ സ്ഥലത്ത് ഒരു ക്ലിപ്പ്ബോർഡ് സൃഷ്ടിക്കപ്പെടുന്നു. ഈ ബഫറിൽ ഡാറ്റ സ്ഥാപിക്കുമ്പോൾ അയയ്ക്കൽ പ്രവർത്തനം അവസാനിക്കുന്നു. പ്രവർത്തനം പ്രാദേശിക സ്വഭാവമുള്ളതാണ്.

പ്രിഫിക്സ് R (തയ്യാറാണ്)

സമ്മതിച്ച അല്ലെങ്കിൽ തയ്യാറാക്കിയ ഡാറ്റാ ട്രാൻസ്മിഷൻ മോഡ്. സ്വീകരിക്കുന്ന പ്രോസസ്സർ ഡാറ്റ സ്വീകരിക്കുന്നതിനുള്ള സന്നദ്ധതയുടെ അടയാളം സജ്ജീകരിച്ച്, സ്വീകരിക്കൽ പ്രവർത്തനം ആരംഭിക്കുമ്പോൾ മാത്രമേ ഡാറ്റ കൈമാറ്റ പ്രവർത്തനം ആരംഭിക്കൂ. പ്രവർത്തനം പ്രാദേശികമല്ലാത്തതാണ്.

പ്രിഫിക്സ് I (ഉടൻ)

നോൺ-ബ്ലോക്കിംഗ് പ്രവർത്തനങ്ങളെ സൂചിപ്പിക്കുന്നു.

MPI_സ്റ്റാറ്റസ് ഘടന

ഒരു സന്ദേശം വായിച്ചതിനുശേഷം, വായിച്ച ഇനങ്ങളുടെ എണ്ണം, സന്ദേശ ഐഡി, അയച്ചയാളുടെ വിലാസം എന്നിങ്ങനെയുള്ള ചില പാരാമീറ്ററുകൾ അജ്ഞാതമായിരിക്കും. സ്റ്റാറ്റസ് പാരാമീറ്റർ ഉപയോഗിച്ച് ഈ വിവരങ്ങൾ ലഭിക്കും. MPI പ്രോഗ്രാമിൽ സ്റ്റാറ്റസ് വേരിയബിളുകൾ വ്യക്തമായി പ്രഖ്യാപിച്ചിരിക്കണം. സി ഭാഷയിൽ, MPI_SOURCE, MPI_TAG, MPI_ERROR എന്നീ മൂന്ന് ഫീൽഡുകളുള്ള MPI_Status തരത്തിൻ്റെ ഘടനയാണ് സ്റ്റാറ്റസ്.

8) യഥാർത്ഥത്തിൽ ലഭിച്ച സന്ദേശ ഘടകങ്ങളുടെ എണ്ണം നിർണ്ണയിക്കാൻ, നിങ്ങൾ ഒരു പ്രത്യേക ഫംഗ്ഷൻ ഉപയോഗിക്കണം MPI_Get_count .

int MPI_Get_count (MPI_Status *status, MPI_Datatype datatype, int *count);

9) MPI_Probe ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലഭിച്ച സന്ദേശത്തിൻ്റെ പാരാമീറ്ററുകൾ വായിക്കാതെ തന്നെ നിർണ്ണയിക്കാനാകും. int MPI_Probe (int source, int tag, MPI_Comm comm, MPI_Status *status);

10) പ്രക്രിയകൾക്കിടയിൽ ഡാറ്റ കൈമാറ്റം ചെയ്യേണ്ട സാഹചര്യങ്ങളിൽ, ഒരു സംയുക്ത പ്രവർത്തനം ഉപയോഗിക്കുന്നത് സുരക്ഷിതമാണ് MPI_Sendrecv . ഈ പ്രവർത്തനത്തിൽ, ബഫ് അറേയിൽ നിന്ന് അയച്ച ഡാറ്റ സ്വീകരിച്ച ഡാറ്റ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.

int MPI_Sendrecv(അസാധുവായ *sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int source, MPI_Datatype * MPI_comm, MPStatus_comm_com);

11) ഒരു നോൺ-ബ്ലോക്കിംഗ് ഓപ്പറേഷൻ MPI_Test ൻ്റെ പൂർത്തീകരണം പരിശോധിക്കുന്നതിനുള്ള പ്രവർത്തനം.

int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status);

ഇതൊരു ലോക്കൽ നോൺ-ബ്ലോക്കിംഗ് ഓപ്പറേഷനാണ്. അഭ്യർത്ഥനയുമായി ബന്ധപ്പെട്ട പ്രവർത്തനം പൂർത്തിയായെങ്കിൽ, ഫ്ലാഗ് = true എന്ന് തിരികെ നൽകുന്നു, കൂടാതെ സ്റ്റാറ്റസിൽ പൂർത്തിയാക്കിയ പ്രവർത്തനത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. പരിശോധിക്കുന്ന പ്രവർത്തനം പൂർത്തിയായിട്ടില്ലെങ്കിൽ, ഫ്ലാഗ് = തെറ്റ് തിരികെ നൽകും, ഈ സാഹചര്യത്തിൽ സ്റ്റാറ്റസിൻ്റെ മൂല്യം നിർവചിച്ചിട്ടില്ല.

12) ഒരു നോൺ-ബ്ലോക്കിംഗ് ഓപ്പറേഷൻ MPI_Request_free പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാതെ ഒരു അഭ്യർത്ഥന റദ്ദാക്കുന്നതിനുള്ള പ്രവർത്തനം.

int MPI_Request_free(MPI_Request *request);

അഭ്യർത്ഥന പരാമീറ്റർ MPI_REQUEST_NULL ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

13) ഒരു പ്രോഗ്രാമിൻ്റെ എല്ലാ പ്രക്രിയകളിലേക്കും (ഡാറ്റ പ്രക്ഷേപണം) ഒരു പ്രക്രിയയിൽ നിന്ന് ഡാറ്റാ ട്രാൻസ്ഫർ ഓപ്പറേഷൻ കാര്യക്ഷമമായി നടപ്പിലാക്കുന്നത് MPI ഫംഗ്ഷൻ ഉപയോഗിച്ച് നേടാം:

int MPI_Bcast(അസാധുവായ *buf,int count,MPI_Datatype തരം,int റൂട്ട്,MPI_Comm comm)

MPI_Bcast ഫംഗ്‌ഷൻ, കോം കമ്മ്യൂണിക്കേറ്ററിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന എല്ലാ പ്രക്രിയകളിലേക്കും ഒരു പ്രോസസ്സ് നമ്പറുള്ള റൂട്ടിൽ നിന്ന് ടൈപ്പ് തരം കൗണ്ട് ഘടകങ്ങൾ അടങ്ങിയ ബഫ് ബഫറിൽ നിന്ന് ഡാറ്റ പ്രക്ഷേപണം ചെയ്യുന്നു.

14) നിങ്ങൾക്ക് ആരുടെയെങ്കിലും സന്ദേശം ലഭിക്കണമെങ്കിൽഅയയ്‌ക്കുന്ന പ്രക്രിയയ്ക്ക് ഉറവിട പാരാമീറ്ററിനായി വ്യക്തമാക്കിയ MPI_ANY_SOURCE മൂല്യം ഉണ്ടായിരിക്കും

15) ഏതെങ്കിലും ടാഗ് ഉപയോഗിച്ച് ഒരു സന്ദേശം ലഭിക്കണമെങ്കിൽ, ടാഗ് പാരാമീറ്ററിനായി മൂല്യം വ്യക്തമാക്കാം MPI_ANY_TAG

16) സ്വീകരിച്ച സന്ദേശത്തിൻ്റെ നിരവധി സവിശേഷതകൾ നിർവചിക്കാൻ സ്റ്റാറ്റസ് പാരാമീറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു:

- status.MPI_SOURCE - റാങ്ക്ലഭിച്ച സന്ദേശം അയയ്ക്കുന്ന പ്രക്രിയ,

- status.MPI_TAG - ലഭിച്ച സന്ദേശത്തിൻ്റെ ടാഗ്.

17) പ്രവർത്തനം

MPI_Get_coun t(MPI_Status *status, MPI_Datatype തരം, int *count)

ലഭിച്ച സന്ദേശത്തിലെ തരം ഘടകങ്ങളുടെ എണ്ണം കൗണ്ട് വേരിയബിളിൽ നൽകുന്നു.

18) എല്ലാ പ്രക്രിയകളിൽ നിന്നും ഒരു പ്രക്രിയയിലേക്ക് ഡാറ്റ കൈമാറുന്ന പ്രവർത്തനങ്ങൾ. ശേഖരിച്ച ഈ പ്രവർത്തനത്തിൽ

മൂല്യങ്ങൾ ഒന്നോ അതിലധികമോ ഡാറ്റ പ്രോസസ്സിംഗ് നടത്തുന്നു (അവസാന പോയിൻ്റ് ഊന്നിപ്പറയുന്നതിന്, ഈ പ്രവർത്തനത്തെ ഡാറ്റ റിഡക്ഷൻ ഓപ്പറേഷൻ എന്നും വിളിക്കുന്നു)

int MPI_Reduce (അസാധുവായ *sendbuf, void *recvbuf,int count,MPI_Datatype തരം, MPI_Op op,int root,MPI_Comm comm)

19) പ്രോസസ് സിൻക്രൊണൈസേഷൻ, അതായത്. MPI ഫംഗ്ഷൻ ഉപയോഗിച്ച് കണക്കുകൂട്ടൽ പ്രക്രിയയുടെ ചില പോയിൻ്റുകളുടെ പ്രക്രിയകളിലൂടെ ഒരേസമയം നേട്ടം ഉറപ്പാക്കുന്നു: int MPI_Barrier(MPI_Comm comm); MPI_Barrier ഫംഗ്‌ഷൻ ഒരു കൂട്ടായ പ്രവർത്തനത്തെ നിർവചിക്കുന്നു, അതിനാൽ, ഉപയോഗിക്കുമ്പോൾ, ഉപയോഗിച്ച ആശയവിനിമയത്തിൻ്റെ എല്ലാ പ്രക്രിയകളും വിളിക്കേണ്ടതാണ്. MPI_Barrier ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ

പ്രോസസ്സ് എക്‌സിക്യൂഷൻ തടഞ്ഞു; കമ്മ്യൂണിക്കേറ്ററിൻ്റെ എല്ലാ പ്രക്രിയകളും MPI_Barrier ഫംഗ്‌ഷൻ വിളിച്ചതിന് ശേഷം മാത്രമേ പ്രോസസ്സ് കണക്കുകൂട്ടലുകൾ തുടരുകയുള്ളൂ.

20) ബഫർ ട്രാൻസ്ഫർ മോഡ് ഉപയോഗിക്കുന്നതിന്, ഒരു MPI മെമ്മറി ബഫർ സൃഷ്ടിക്കുകയും കൈമാറുകയും വേണം

സന്ദേശങ്ങൾ ബഫർ ചെയ്യാൻ - ഇതിനായി ഉപയോഗിക്കുന്ന ഫംഗ്‌ഷൻ ഇതുപോലെ കാണപ്പെടുന്നു: int MPI_Buffer_attach (void *buf, int size),

- ബഫറിംഗ് സന്ദേശങ്ങൾക്കുള്ള ബഫ് മെമ്മറി ബഫർ,

- വലിപ്പം - ബഫർ വലിപ്പം.

21) ബഫറിനൊപ്പം ജോലി പൂർത്തിയാക്കിയ ശേഷം, ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇത് MPI-യിൽ നിന്ന് വിച്ഛേദിക്കണം:

int MPI_Buffer_detach (void *buf, int *size).

22) MPI ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഡാറ്റാ ട്രാൻസ്മിഷൻ, റിസപ്ഷൻ ഓപ്പറേഷനുകളുടെ കാര്യക്ഷമവും ഉറപ്പുള്ളതുമായ ഒരേസമയം നിർവ്വഹണം കൈവരിക്കാൻ കഴിയും:

int MPI_Sendrecv (അസാധുവായ *sbuf,int സ്കൌണ്ട്,MPI_Datatype ശൈലി,int dest, int stag, void *rbuf,int rcount,MPI_Datatype

rtype,int source,int rtag, MPI_Comm comm, MPI_Status *സ്റ്റാറ്റസ്)

23) സന്ദേശങ്ങൾ ഒരേ തരത്തിലുള്ളതാണെങ്കിൽ, MPI-ന് ഒരൊറ്റ ബഫർ ഉപയോഗിക്കാനുള്ള കഴിവുണ്ട്: intMPI_Sendrecv_replace (void *buf, int count, MPI_Datatype തരം, int dest,

int stag, int source, int rtag, MPI_Comm comm, MPI_Status* സ്റ്റാറ്റസ്)

24) ഒരു പ്രക്രിയയിൽ നിന്ന് എല്ലാ പ്രക്രിയകളിലേക്കും (ഡാറ്റ ഡിസ്ട്രിബ്യൂഷൻ) ഡാറ്റ ട്രാൻസ്മിറ്റ് ചെയ്യുന്നതിനുള്ള സാമാന്യവൽക്കരിച്ച പ്രവർത്തനം, പ്രക്ഷേപണത്തിൽ നിന്ന് വ്യത്യസ്തമാണ്, ഈ പ്രക്രിയ വ്യത്യസ്ത ഡാറ്റയെ പ്രക്രിയകളിലേക്ക് കൈമാറുന്നു (ചിത്രം 4.4 കാണുക). ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഈ പ്രവർത്തനം പൂർത്തിയാക്കാൻ കഴിയും:

int MPI_Scatter (അസാധുവായ *sbuf,int സ്കൌണ്ട്,MPI_Datatype ശൈലി,

25) എല്ലാ പ്രോസസറുകളിൽ നിന്നും ഒരു പ്രക്രിയയിലേക്ക് (ഡാറ്റ ശേഖരണം) സാമാന്യവൽക്കരിച്ച ഡാറ്റ കൈമാറ്റത്തിൻ്റെ പ്രവർത്തനം ഡാറ്റ വിതരണ നടപടിക്രമത്തിൻ്റെ വിപരീതമാണ് (ചിത്രം 4.5 കാണുക). MPI-യിൽ ഈ പ്രവർത്തനം നടത്താൻ ഒരു ഫംഗ്ഷൻ ഉണ്ട്:

int MPI_Gather (അസാധുവായ *sbuf,int സ്കൌണ്ട്,MPI_Datatype ശൈലി,

void *rbuf,int rcount,MPI_Datatype rtype, int root, MPI_Comm comm)

26) MPI_Gather ഫംഗ്‌ഷൻ ഉപയോഗിക്കുമ്പോൾ, ഡാറ്റ ശേഖരണം മാത്രമാണ് നടത്തുന്നത് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്

ഒരു പ്രക്രിയയിൽ. ഓരോ ആശയവിനിമയ പ്രക്രിയകളിലും ശേഖരിച്ച എല്ലാ ഡാറ്റയും നേടുന്നതിന്

നിങ്ങൾ ശേഖരണത്തിൻ്റെയും വിതരണത്തിൻ്റെയും പ്രവർത്തനം ഉപയോഗിക്കേണ്ടതുണ്ട്:

int MPI_Allgather (അസാധുവായ *sbuf, int സ്കൌണ്ട്, MPI_Datatype ശൈലി, void *rbuf, int rcount, MPI_Datatype rtype, MPI_Comm comm)

27) എല്ലാ പ്രക്രിയകളിൽ നിന്നും എല്ലാ പ്രക്രിയകളിലേക്കും ഡാറ്റ കൈമാറുന്നത് ഏറ്റവും സാധാരണമായ ഡാറ്റാ ട്രാൻസ്ഫർ ഓപ്പറേഷനാണ് (ചിത്രം 4.6 കാണുക). ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഈ പ്രവർത്തനം പൂർത്തിയാക്കാൻ കഴിയും:

int MPI_Alltoall (അസാധുവായ *sbuf,int സ്കൌണ്ട്,MPI_Datatype ശൈലി, അസാധുവായ *rbuf,int rcount,MPI_Datatype rtype,MPI_Comm comm)

28) MPI_Reduce ഫംഗ്ഷൻ ഡാറ്റ റിഡക്ഷൻ ഫലങ്ങൾ നൽകുന്നു

ഒരു പ്രക്രിയയിൽ മാത്രം. ഓരോ ആശയവിനിമയ പ്രക്രിയയിലും ഡാറ്റ കുറയ്ക്കുന്നതിൻ്റെ ഫലങ്ങൾ ലഭിക്കുന്നതിന്, നിങ്ങൾ റിഡക്ഷൻ, ഡിസ്ട്രിബ്യൂഷൻ ഫംഗ്ഷൻ ഉപയോഗിക്കണം:

int MPI_Allreduce (void *sendbuf, void *recvbuf,int count,MPI_Datatype തരം, MPI_Op op,MPI_Comm comm).

29) എല്ലാ ഭാഗിക റിഡക്ഷൻ ഫലങ്ങളും ലഭിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്ന ഡാറ്റാ ശേഖരണത്തിൻ്റെയും പ്രോസസ്സിംഗ് പ്രവർത്തനത്തിൻ്റെയും മറ്റൊരു പതിപ്പ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ലഭിക്കും:

int MPI_Scan (അസാധുവായ *sendbuf, void *recvbuf,int count,MPI_Datatype തരം, MPI_Op op,MPI_Comm comm).

MPI_Scan ഫംഗ്‌ഷൻ്റെ പൊതുവായ എക്‌സിക്യൂഷൻ ഡയഗ്രം ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു. 4.7 ലഭിച്ച സന്ദേശങ്ങളുടെ ഘടകങ്ങൾ, പ്രോസസ്സുകൾ വഴി കൈമാറുന്ന സന്ദേശങ്ങളുടെ അനുബന്ധ ഘടകങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിൻ്റെ ഫലങ്ങളെ പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ റാങ്ക് i, 0≤i ഉള്ള ഒരു പ്രക്രിയയിൽ ഫലങ്ങൾ നേടുക

30) പാക്കേജിംഗ് ആരംഭിക്കുന്നതിന് മുമ്പ് ബഫ്‌പോസ് വേരിയബിളിൻ്റെ പ്രാരംഭ മൂല്യം രൂപീകരിക്കുകയും തുടർന്ന് ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് സജ്ജീകരിക്കുകയും വേണം. MPI_Pack. ആവശ്യമായ എല്ലാ ഡാറ്റയും പാക്ക് ചെയ്യുന്നതിന് MPI_Pack ഫംഗ്‌ഷനെ തുടർച്ചയായി വിളിക്കുന്നു.

int MPI_Pack_size (int count, MPI_Datatype തരം, MPI_Comm comm, int *size)

31) ആവശ്യമായ എല്ലാ ഡാറ്റയും പാക്ക് ചെയ്ത ശേഷം, തയ്യാറാക്കിയ ബഫർ വ്യക്തമാക്കിയ MPI_PACKED തരം ഉപയോഗിച്ച് ഡാറ്റാ ട്രാൻസ്ഫർ ഫംഗ്‌ഷനുകളിൽ ഉപയോഗിക്കാം.

MPI_PACKED എന്ന തരത്തിലുള്ള ഒരു സന്ദേശം ലഭിച്ച ശേഷം, ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഡാറ്റ അൺപാക്ക് ചെയ്യാൻ കഴിയും:

int MPI_Unpack (void *buf, int bufsize, int *bufpos, void *data, int count, MPI_Datatype തരം, MPI_Comm comm)

കോംപ്ലക്സ് ഇൻസ്ട്രക്ഷൻ സെറ്റ് കമ്പ്യൂട്ടർ

CISC (ഇംഗ്ലീഷ് കോംപ്ലക്സ് ഇൻസ്ട്രക്ഷൻ സെറ്റ് കമ്പ്യൂട്ടിംഗ്, അല്ലെങ്കിൽ ഇംഗ്ലീഷ് കോംപ്ലക്സ് ഇൻസ്ട്രക്ഷൻ സെറ്റ് കമ്പ്യൂട്ടർ -

പൂർണ്ണമായ നിർദ്ദേശങ്ങളുള്ള കമ്പ്യൂട്ടർ) ഒരു പ്രോസസർ ഡിസൈൻ ആശയമാണ്, അത് ഇനിപ്പറയുന്ന ഗുണങ്ങളാൽ സവിശേഷതയാണ്:

താരതമ്യേന ചെറിയ പൊതു ഉദ്ദേശ്യ രജിസ്റ്ററുകൾ;

· മെഷീൻ നിർദ്ദേശങ്ങളുടെ ഒരു വലിയ സംഖ്യ, അവയിൽ ചിലത് ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഓപ്പറേറ്റർമാർക്ക് സമാനമായി സെമാൻ്റിക് ആയി ലോഡ് ചെയ്യുകയും നിരവധി ക്ലോക്ക് സൈക്കിളുകളിൽ നടപ്പിലാക്കുകയും ചെയ്യുന്നു;

· ഒരു വലിയ സംഖ്യ അഭിസംബോധന രീതികൾ;

· വിവിധ ബിറ്റ് വലുപ്പങ്ങളുള്ള ഒരു വലിയ കമാൻഡ് ഫോർമാറ്റുകൾ;

· രണ്ട്-വിലാസ കമാൻഡ് ഫോർമാറ്റിൻ്റെ ആധിപത്യം;

· തരം പ്രോസസ്സിംഗ് കമാൻഡുകളുടെ സാന്നിധ്യംരജിസ്റ്റർ-മെമ്മറി.

പോരായ്മകൾ:

ഹാർഡ്വെയറിൻ്റെ ഉയർന്ന വില; കണക്കുകൂട്ടലുകളുടെ സമാന്തരവൽക്കരണത്തിലെ ബുദ്ധിമുട്ടുകൾ.

CISC ഇൻസ്ട്രക്ഷൻ സിസ്റ്റം നിർമ്മാണ സാങ്കേതികത മറ്റൊരു സാങ്കേതികതയ്ക്ക് വിപരീതമാണ് - RISC. ഈ ആശയങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം പ്രോഗ്രാമിംഗ് രീതികളിലാണ്, യഥാർത്ഥ പ്രോസസ്സർ ആർക്കിടെക്ചറിലല്ല. മിക്കവാറും എല്ലാ ആധുനിക പ്രോസസ്സറുകളും RISC, CISC ടൈപ്പ് ഇൻസ്ട്രക്ഷൻ സെറ്റുകൾ അനുകരിക്കുന്നു.

കുറച്ച നിർദ്ദേശങ്ങൾ കമ്പ്യൂട്ടർ സജ്ജമാക്കുക

ഇത് RISC ആർക്കിടെക്ചറിൻ്റെ തത്വങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്: ഫിക്സഡ് ഇൻസ്ട്രക്ഷൻ ഫോർമാറ്റ്, രജിസ്റ്റർ പ്രവർത്തനങ്ങൾ, നിർദ്ദേശങ്ങളുടെ സിംഗിൾ സൈക്കിൾ എക്സിക്യൂഷൻ, ലളിതമായ വിലാസ രീതികൾ, ഒരു വലിയ രജിസ്റ്റർ ഫയൽ. അതേ സമയം, ഈ ആർക്കിടെക്ചറിനെ മറ്റ് RISC പ്രോസസറുകളുടെ ആർക്കിടെക്ചറുകളിൽ നിന്ന് വേർതിരിക്കുന്ന നിരവധി പ്രധാന സവിശേഷതകൾ ഉണ്ട്. ഇവ ഉൾപ്പെടുന്നു: ഓരോ ആക്യുവേറ്ററുകൾക്കുമുള്ള ഒരു സ്വതന്ത്ര സെറ്റ് രജിസ്റ്ററുകൾ; സിസ്റ്റത്തിൽ വ്യക്തിഗത CISC പോലുള്ള നിർദ്ദേശങ്ങൾ ഉൾപ്പെടുത്തൽ; ഒരു "കാലതാമസം സംഭവിച്ച പരിവർത്തന" സംവിധാനത്തിൻ്റെ അഭാവം; സോപാധിക ജമ്പുകൾ നടപ്പിലാക്കുന്നതിനുള്ള ഒരു യഥാർത്ഥ മാർഗം. മൈക്രോപ്രൊസസർ ആർക്കിടെക്ചറുകളുടെ പ്രധാന പ്രയോഗങ്ങൾ ഉയർന്ന പ്രകടനമുള്ള സെർവറുകളും സൂപ്പർ കമ്പ്യൂട്ടറുകളുമാണ്.

മെമ്മറി നിർദ്ദേശങ്ങളിൽ നിന്ന് പ്രോസസ്സിംഗ് നിർദ്ദേശങ്ങൾ വേർതിരിക്കുകയും കാര്യക്ഷമമായ പൈപ്പ്ലൈനിംഗിന് ഊന്നൽ നൽകുകയും ചെയ്യുന്ന ഒരു ആർക്കിടെക്ചറിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഇത്തരം കമ്പ്യൂട്ടറുകൾ. ഏതൊരു നിർദ്ദേശത്തിൻ്റെയും നിർവ്വഹണത്തിന് കുറച്ച് മെഷീൻ സൈക്കിളുകൾ (വെയിലത്ത് ഒരു മെഷീൻ സൈക്കിൾ) എടുക്കുന്ന വിധത്തിലാണ് ഇൻസ്ട്രക്ഷൻ സിസ്റ്റം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പ്രകടനം വർദ്ധിപ്പിക്കുന്നതിനായി കമാൻഡുകൾ നടപ്പിലാക്കുന്നതിനുള്ള യുക്തി തന്നെ ഫേംവെയർ നടപ്പിലാക്കുന്നതിനുപകരം ഹാർഡ്‌വെയറിലാണ് ശ്രദ്ധ കേന്ദ്രീകരിച്ചത്. കമാൻഡ് ഡീകോഡിംഗ് ലോജിക് ലളിതമാക്കാൻ, നിശ്ചിത ദൈർഘ്യമുള്ള കമാൻഡുകൾ ഉപയോഗിച്ചു

ഒപ്പം നിശ്ചിത ഫോർമാറ്റ്.

IN ട്രാൻസിഷൻ ടാർഗെറ്റ് അഡ്രസ് ബഫർ സാങ്കേതികവിദ്യയുടെ കാര്യം എന്താണ്?

IN സംക്രമണങ്ങളുടെ ദിശ ചലനാത്മകമായി പ്രവചിക്കുന്നതിനുള്ള ഒരു സംവിധാനം പ്രൊസസർ നൽകുന്നു. ഇതിനോടൊപ്പം

ബ്രാഞ്ച് ടാർഗെറ്റ് ബഫർ (BTB) എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ചെറിയ കാഷെ മെമ്മറി, കൂടാതെ രണ്ട് സ്വതന്ത്ര ജോഡി ഇൻസ്ട്രക്ഷൻ പ്രീഫെച്ച് ബഫറുകൾ (ഒരു പൈപ്പ് ലൈനിൽ രണ്ട് 32-ബിറ്റ് ബഫറുകൾ) എന്നിവയാണ് ചിപ്പിലെ ലക്ഷ്യം. ബ്രാഞ്ച് ടാർഗെറ്റ് വിലാസ ബഫർ പ്രീഫെച്ച് ബഫറുകളിലുള്ള നിർദ്ദേശങ്ങളുടെ വിലാസങ്ങൾ സംഭരിക്കുന്നു. പ്രിഫെച്ച് ബഫറുകളുടെ പ്രവർത്തനം ക്രമീകരിച്ചിരിക്കുന്നത് ഏത് സമയത്തും, ബന്ധപ്പെട്ട ജോഡിയുടെ ബഫറുകളിലൊന്നിലേക്ക് മാത്രം നിർദ്ദേശങ്ങൾ ലഭ്യമാക്കുന്ന തരത്തിലാണ്. നിർദ്ദേശ സ്ട്രീമിൽ ഒരു ബ്രാഞ്ച് പ്രവർത്തനം കണ്ടെത്തുമ്പോൾ, കണക്കാക്കിയ ബ്രാഞ്ച് വിലാസം BTB ബഫറിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസങ്ങളുമായി താരതമ്യം ചെയ്യുന്നു. ഒരു പൊരുത്തമുണ്ടെങ്കിൽ, ബ്രാഞ്ച് നടക്കുമെന്ന് പ്രവചിക്കുകയും മറ്റൊരു പ്രീഫെച്ച് ബഫർ പ്രവർത്തനക്ഷമമാക്കുകയും നിർവ്വഹണത്തിനായി അനുബന്ധ പൈപ്പ്ലൈനിലേക്ക് കമാൻഡുകൾ നൽകാൻ തുടങ്ങുകയും ചെയ്യുന്നു. ഒരു പൊരുത്തക്കേട് ഉണ്ടെങ്കിൽ, ബ്രാഞ്ച് എക്സിക്യൂട്ട് ചെയ്യില്ലെന്നും പ്രീഫെച്ച് ബഫർ സ്വിച്ച് ചെയ്യില്ലെന്നും അനുമാനിക്കപ്പെടുന്നു, ഇത് സാധാരണ കമാൻഡ് ഇഷ്യു ചെയ്യുന്ന ക്രമം തുടരുന്നു. ഇത് കൺവെയർ പ്രവർത്തനരഹിതമായ സമയം ഒഴിവാക്കുന്നു

ഘടനാപരമായ വൈരുദ്ധ്യങ്ങളും അവ കുറയ്ക്കുന്നതിനുള്ള വഴികളും

കമാൻഡ് എക്‌സിക്യൂഷൻ്റെ സംയോജിത രീതിക്ക് പൊതുവെ പൈപ്പ് ലൈനിലെ കമാൻഡിൻ്റെ സാധ്യമായ എല്ലാ കോമ്പിനേഷനുകളും പരിഹരിക്കുന്നതിന് ഫംഗ്ഷണൽ യൂണിറ്റുകളുടെ പൈപ്പ്ലൈനിംഗും വിഭവങ്ങളുടെ തനിപ്പകർപ്പും ആവശ്യമാണ്. കമാൻഡുകളുടെ ഏതെങ്കിലും സംയോജനം പരാജയപ്പെടുകയാണെങ്കിൽ

റിസോഴ്സ് വൈരുദ്ധ്യം കാരണം അംഗീകരിക്കപ്പെടും, അപ്പോൾ യന്ത്രത്തിന് ഘടനാപരമായ വൈരുദ്ധ്യമുണ്ടെന്ന് പറയപ്പെടുന്നു. ഘടനാപരമായ വൈരുദ്ധ്യങ്ങൾ ഉണ്ടാകാനിടയുള്ള മെഷീനുകളുടെ ഏറ്റവും സാധാരണമായ ഉദാഹരണം പൂർണ്ണമായും കൺവെയറൈസ് ചെയ്യാത്ത പ്രവർത്തന ഉപകരണങ്ങളുള്ള മെഷീനുകളാണ്.

ചെറുതാക്കൽ: ആവശ്യമായ ഉപകരണം ലഭ്യമാകുന്നതുവരെ പൈപ്പ്ലൈൻ കമാൻഡുകളിലൊന്നിൻ്റെ നിർവ്വഹണം താൽക്കാലികമായി നിർത്തുന്നു.

ഡാറ്റ വൈരുദ്ധ്യങ്ങൾ, പൈപ്പ്ലൈൻ സ്റ്റോപ്പുകൾ, ബൈപാസ് മെക്കാനിസം നടപ്പിലാക്കൽ

കൺവെയർ സിസ്റ്റങ്ങളുടെ പ്രവർത്തനത്തിൽ കാര്യമായ സ്വാധീനം ചെലുത്തുന്ന ഘടകങ്ങളിലൊന്നാണ് ഇൻ്റർ-ഇൻസ്ട്രക്ഷൻ ലോജിക്കൽ ഡിപൻഡൻസികൾ. പൈപ്പ്‌ലൈൻ പ്രോസസ്സിംഗിൻ്റെ ഉപയോഗത്തിന് ഓപ്പറാൻറ് കോളുകളുടെ ക്രമം മാറ്റാൻ കഴിയുമ്പോൾ ഡാറ്റ വൈരുദ്ധ്യങ്ങൾ ഉണ്ടാകുന്നു, അതിനാൽ പൈപ്പ് ലൈൻ ചെയ്യാത്ത മെഷീനിൽ നിർദ്ദേശങ്ങൾ തുടർച്ചയായി നടപ്പിലാക്കുമ്പോൾ നിരീക്ഷിക്കുന്ന ക്രമത്തിൽ നിന്ന് ഈ ഓർഡർ വ്യത്യസ്തമായിരിക്കും. ഈ ഉദാഹരണത്തിൽ ഉന്നയിക്കപ്പെട്ട പ്രശ്നം ഡാറ്റ ഫോർവേഡിംഗ്, ഡാറ്റ ബൈപാസിംഗ് അല്ലെങ്കിൽ ചിലപ്പോൾ ഷോർട്ട് സർക്യൂട്ട് എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ലളിതമായ ഹാർഡ്‌വെയർ ടെക്നിക് ഉപയോഗിച്ച് പരിഹരിക്കാൻ കഴിയും.

പൈപ്പ് ലൈൻ താൽക്കാലികമായി നിർത്തുന്നതിന് കാരണമാകുന്ന ഡാറ്റ വൈരുദ്ധ്യങ്ങൾ

പകരം, ഉദാഹരണം ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ പൈപ്പ്‌ലൈൻ ഇൻ്റർലുക്ക് ഹാർഡ്‌വെയർ എന്ന് വിളിക്കുന്ന അധിക ഹാർഡ്‌വെയർ ആവശ്യമാണ്. പൊതുവേ, ഇത്തരത്തിലുള്ള ഉപകരണങ്ങൾ പൊരുത്തക്കേടുകൾ കണ്ടെത്തുകയും ഒരു സംഘർഷം നിലനിൽക്കുന്നിടത്തോളം പൈപ്പ്ലൈൻ താൽക്കാലികമായി നിർത്തുകയും ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, ഈ ഹാർഡ്‌വെയർ, ഡാറ്റ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന നിർദ്ദേശത്തോടെ ആരംഭിക്കുന്ന പൈപ്പ്‌ലൈൻ താൽക്കാലികമായി നിർത്തുന്നു, മുമ്പത്തെ നിർദ്ദേശം, അതിൻ്റെ ഫലം നമ്മുടേതായ ഒരു ഓപ്പറാൻറ് ആ ഫലം ​​പുറപ്പെടുവിക്കുന്നു. ഈ ഉപകരണം ഒരു പ്രൊഡക്ഷൻ ലൈൻ സ്തംഭിക്കുന്നതിനോ അല്ലെങ്കിൽ ഘടനാപരമായ വൈരുദ്ധ്യങ്ങളുടെ കാര്യത്തിലെന്നപോലെ ഒരു "ബബിൾ" പ്രത്യക്ഷപ്പെടുന്നതിനോ കാരണമാകുന്നു.

സോപാധിക ബ്രാഞ്ച് പ്രവചന ബഫറുകൾ

സോപാധിക ബ്രാഞ്ച് പ്രവചന ബഫർ എന്നത് ബ്രാഞ്ച് നിർദ്ദേശത്തിൻ്റെ വിലാസത്തിൻ്റെ ഏറ്റവും കുറഞ്ഞ ബിറ്റുകൾ ഉപയോഗിച്ച് അഭിസംബോധന ചെയ്യാവുന്ന ഒരു ചെറിയ മെമ്മറിയാണ്. ഈ മെമ്മറിയുടെ ഓരോ സെല്ലിലും ഒരു ബിറ്റ് അടങ്ങിയിരിക്കുന്നു, ഇത് മുമ്പത്തെ ബ്രാഞ്ച് എക്സിക്യൂട്ട് ചെയ്തോ ഇല്ലയോ എന്ന് സൂചിപ്പിക്കുന്നു. ഇത്തരത്തിലുള്ള ഏറ്റവും ലളിതമായ ബഫർ ഇതാണ്. ഇതിന് ടാഗുകളൊന്നുമില്ല, ബ്രാഞ്ച് ടാർഗെറ്റ് വിലാസത്തിൻ്റെ മൂല്യം കണക്കാക്കാൻ ആവശ്യമായ സമയത്തേക്കാൾ കാലതാമസം കൂടുതലാണെങ്കിൽ ബ്രാഞ്ച് ലേറ്റൻസി കുറയ്ക്കുന്നതിന് മാത്രമേ ഇത് ഉപയോഗപ്രദമാകൂ. ബ്രാഞ്ച് പ്രവചന ബഫർ പൈപ്പ്‌ലൈനിൻ്റെ ഇൻസ്ട്രക്ഷൻ ഫെച്ച് ഘട്ടത്തിൽ (IF) നിർദ്ദേശ വിലാസം ആക്‌സസ് ചെയ്‌ത ഒരു ചെറിയ സമർപ്പിത കാഷായി അല്ലെങ്കിൽ ഓരോ ഇൻസ്ട്രക്ഷൻ കാഷെ ബ്ലോക്കുമായി ബന്ധപ്പെട്ട ഒരു ജോടി ബിറ്റുകളായി ഓരോ നിർദ്ദേശങ്ങൾക്കൊപ്പവും നടപ്പിലാക്കാം.

സി ഭാഷയിൽ സമാന്തരവൽക്കരണം
ഉദാഹരണം 3b. ഫോർട്രാനിലെ സമാന്തരവൽക്കരണം
ഉദാഹരണം 4a. സി ഭാഷയിൽ സിസ്റ്റം ടൈമറിൻ്റെ സവിശേഷതകൾ നിർണ്ണയിക്കുന്നു
ഉദാഹരണം 4b. ഫോർട്രാനിലെ സിസ്റ്റം ടൈമർ സവിശേഷതകൾ നിർവചിക്കുന്നു

1.4 പ്രത്യേക പ്രക്രിയകൾക്കിടയിൽ സന്ദേശങ്ങൾ അയയ്ക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നു

1.4.1. പോയിൻ്റ്-ടു-പോയിൻ്റ് പ്രവർത്തനങ്ങൾ

1.4.2. തടയൽ ഉപയോഗിച്ച് സന്ദേശങ്ങൾ അയയ്ക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നു

ഉദാഹരണം 5a. സി ഭാഷയിൽ രണ്ട് പ്രക്രിയകൾക്കിടയിൽ സന്ദേശങ്ങളുടെ കൈമാറ്റം
ഉദാഹരണം 5 ബി. ഫോർട്രാനിലെ രണ്ട് പ്രക്രിയകൾക്കിടയിൽ സന്ദേശങ്ങളുടെ കൈമാറ്റം
ഉദാഹരണം 6a. സിയിലെ ഇരട്ട, ഒറ്റ പ്രക്രിയകൾ തമ്മിലുള്ള സന്ദേശ കൈമാറ്റം
ഉദാഹരണം 6b. ഫോർട്രാനിലെ ഇരട്ട, ഒറ്റ പ്രക്രിയകൾ തമ്മിലുള്ള സന്ദേശ കൈമാറ്റം
ഉദാഹരണം 7a. സിയിൽ നിലവിലില്ലാത്ത ഒരു പ്രക്രിയയിലേക്ക് കൈമാറുന്നു
ഉദാഹരണം 7b. ഫോർട്രാനിൽ നിലവിലില്ലാത്ത ഒരു പ്രക്രിയയിലേക്ക് കൈമാറുന്നു
ഉദാഹരണം 8a. ബഫർ ചെയ്ത ഡാറ്റ സി ഭാഷയിൽ അയയ്ക്കുന്നു
ഉദാഹരണം 8b. ഫോർട്രാൻ ഭാഷയിൽ ബഫർ ചെയ്ത ഡാറ്റ അയയ്ക്കുന്നു
ഉദാഹരണം 9a. സി ഭാഷയിൽ സന്ദേശ ആട്രിബ്യൂട്ടുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നു
ഉദാഹരണം 9b. ഫോർട്രാനിലെ സന്ദേശ ആട്രിബ്യൂട്ടുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നു
ഉദാഹരണം 10a. സി ഭാഷയിലെ ലേറ്റൻസിയുടെയും ത്രൂപുട്ടിൻ്റെയും നിർവ്വചനം
ഉദാഹരണം 10 ബി. ഫോർട്രാനിലെ ലേറ്റൻസിയും ത്രൂപുട്ടും നിർവചിക്കുന്നു

1.4.3. തടയാതെ സന്ദേശങ്ങൾ അയയ്ക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നു

ഉദാഹരണം 11a. C-യിലെ നോൺ-ബ്ലോക്കിംഗ് ഓപ്പറേഷനുകൾ ഉപയോഗിച്ച് ഒരു റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 11 ബി. ഫോർട്രാനിലെ നോൺ-ബ്ലോക്കിംഗ് ഓപ്പറേഷനുകൾ ഉപയോഗിച്ച് റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 12a. സി ഭാഷയിൽ ആശയവിനിമയ പദ്ധതി "മാസ്റ്റർ - തൊഴിലാളികൾ"
ഉദാഹരണം 12 ബി. ഫോർട്രാൻ ഭാഷയിൽ ആശയവിനിമയ ഡയഗ്രം "മാസ്റ്റർ - തൊഴിലാളികൾ"
ഉദാഹരണം 13a. സി ഭാഷയിൽ മാട്രിക്സ് ട്രാൻസ്പോസിഷൻ
ഉദാഹരണം 13 ബി. ഫോർട്രാനിൽ ഒരു മാട്രിക്സ് ട്രാൻസ്പോസ് ചെയ്യുന്നു

1.4.4. തീർപ്പുകൽപ്പിക്കാത്ത ആശയവിനിമയ അഭ്യർത്ഥനകൾ

ഉദാഹരണം 14a. സി ഭാഷയിലെ ഡിഫർഡ് ക്വറികൾ ഉപയോഗിച്ച് റിംഗ് ടോപ്പോളജി സഹിതം എക്സ്ചേഞ്ച് ചെയ്യുന്ന ഒരു ആവർത്തന രീതിയുടെ സ്കീം
ഉദാഹരണം 14 ബി. ഫോർട്രാനിലെ മാറ്റിവെച്ച അന്വേഷണങ്ങൾ ഉപയോഗിച്ച് റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുന്ന ഒരു ആവർത്തന രീതിയുടെ സ്കീം

1.4.5. സ്തംഭനാവസ്ഥയിലുള്ള സാഹചര്യങ്ങൾ

ഉദാഹരണം 15a. സി ഭാഷയിൽ MPI_Sendrecv നടപടിക്രമം ഉപയോഗിച്ച് ഒരു റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 15 ബി. ഫോർട്രാനിലെ MPI_SENDRECV നടപടിക്രമം ഉപയോഗിച്ച് ഒരു റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക

1.5 കൂട്ടായ പ്രക്രിയ ഇടപെടലുകൾ

1.5.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.5.2. തടസ്സം

ഉദാഹരണം 16a. സി ഭാഷയിൽ മോഡലിംഗ് ബാരിയർ സിൻക്രൊണൈസേഷൻ
ഉദാഹരണം 16 ബി. ഫോർട്രാനിലെ മോഡലിംഗ് ബാരിയർ സിൻക്രൊണൈസേഷൻ

1.5.3. കൂട്ടായ ഡാറ്റ കൈമാറ്റ പ്രവർത്തനങ്ങൾ

1.5.4. ആഗോള പ്രവർത്തനങ്ങൾ

ഉദാഹരണം 17a. ഇരട്ടിപ്പിക്കൽ സ്കീമും C ഭാഷയിൽ MPI_Reduce എന്ന കൂട്ടായ പ്രവർത്തനവും ഉപയോഗിച്ച് ആഗോള സംഗ്രഹം മാതൃകയാക്കുന്നു
ഉദാഹരണം 17 ബി. ഇരട്ടിപ്പിക്കൽ പദ്ധതിയും ഫോർട്രാനിലെ MPI_Reduce എന്ന കൂട്ടായ പ്രവർത്തനവും ഉപയോഗിച്ച് ആഗോള സമ്മേഷൻ മോഡലിംഗ്

1.5.5. കസ്റ്റം ഗ്ലോബൽ ഓപ്പറേഷൻസ്

ഉദാഹരണം 18a. സി ഭാഷയിൽ ഇഷ്‌ടാനുസൃത ആഗോള പ്രവർത്തനം
ഉദാഹരണം 18b. ഫോർട്രാനിലെ ഇഷ്‌ടാനുസൃത ആഗോള പ്രവർത്തനം

1.6 ഗ്രൂപ്പുകളും ആശയവിനിമയക്കാരും

1.6.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.6.2. പ്രോസസ് ഗ്രൂപ്പുകളുമായുള്ള പ്രവർത്തനങ്ങൾ

ഉദാഹരണം 19a. സി ഭാഷയിൽ ഗ്രൂപ്പുകളുമായി പ്രവർത്തിക്കുന്നു
ഉദാഹരണം 19 ബി. ഫോർട്രാനിലെ ഗ്രൂപ്പുകളുമായി പ്രവർത്തിക്കുന്നു

1.6.3. ആശയവിനിമയം നടത്തുന്നവരുമായുള്ള പ്രവർത്തനങ്ങൾ

ഉദാഹരണം 20a. സിയിലെ ഒരു ആശയവിനിമയം തകർക്കുന്നു
ഉദാഹരണം 20 ബി. ഫോർട്രാനിൽ ഒരു കമ്മ്യൂണിക്കേറ്ററിനെ വിഭജിക്കുന്നു
ഉദാഹരണം 21a. C ഭാഷയിൽ പ്രക്രിയകളുടെ പുനർനമ്പറിങ്ങ്
ഉദാഹരണം 21 ബി. ഫോർട്രാനിലെ റീനമ്പറിംഗ് പ്രക്രിയകൾ

1.6.4. ആശയവിനിമയം നടത്തുന്നവർ

ഉദാഹരണം 22a. സി ഭാഷയിൽ ഒരു ഇൻ്റർകമ്മ്യൂണിക്കേറ്റർ ഉപയോഗിക്കുന്ന മാസ്റ്റർ-വർക്കർ സ്കീം
ഉദാഹരണം 22 ബി. ഫോർട്രാനിലെ ഒരു ഇൻ്റർകമ്മ്യൂണിക്കേറ്റർ ഉപയോഗിക്കുന്ന മാസ്റ്റർ-വർക്കർ സർക്യൂട്ട്

1.6.5. ഗുണവിശേഷങ്ങൾ

1.7 വെർച്വൽ ടോപ്പോളജികൾ

1.7.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.7.2. കാർട്ടീഷ്യൻ ടോപ്പോളജി

1.7.3. ഗ്രാഫ് ടോപ്പോളജി

ഉദാഹരണം 23a. സി ഭാഷയിൽ ഗ്രാഫ് ടോപ്പോളജി ഉപയോഗിക്കുന്ന മാസ്റ്റർ-വർക്കർ ഡയഗ്രം
ഉദാഹരണം 23b. ഫോർട്രാനിലെ ഗ്രാഫ് ടോപ്പോളജി ഉപയോഗിക്കുന്ന മാസ്റ്റർ-വർക്കർ സ്കീം

1.8 വ്യത്യസ്ത തരം ഡാറ്റ അയയ്ക്കുന്നു

1.8.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.8.2. ലഭിച്ച ഡാറ്റ തരങ്ങൾ

ഉദാഹരണം 24a. സി ഭാഷയിൽ മാട്രിക്സ് നിരകൾ വിപരീത ക്രമത്തിൽ പുനഃക്രമീകരിക്കുന്നു
ഉദാഹരണം 24 ബി. ഫോർട്രാനിൽ മാട്രിക്സ് നിരകൾ വിപരീത ക്രമത്തിൽ പുനഃക്രമീകരിക്കുന്നു

1.8.3. ഡാറ്റ പാക്കിംഗ്

ഉദാഹരണം 25a. സി ഭാഷയിൽ പാക്ക് ചെയ്ത ഡാറ്റ അയയ്ക്കുന്നു
ഉദാഹരണം 25b. ഫോർട്രാനിൽ പാക്ക് ചെയ്ത ഡാറ്റ അയയ്ക്കുന്നു

1.9 വിവര വസ്തു

1.9.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.9.2. വിവര വസ്തു ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

1.10 ഡൈനാമിക് പ്രോസസ് കൺട്രോൾ

1.10.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.10.2.പ്രക്രിയകളുടെ സൃഷ്ടി

മാസ്റ്റർ.സി
അടിമ.സി
ഉദാഹരണം 26a. സി ഭാഷയിൽ പ്രോസസ് സ്പോണിംഗ് ഉപയോഗിക്കുന്ന മാസ്റ്റർ-വർക്കർ സ്കീം
master.f
അടിമ.എഫ്
ഉദാഹരണം 26b. ഫോർട്രാനിലെ പ്രോസസ് സ്പോണിംഗ് ഉപയോഗിച്ചുള്ള മാസ്റ്റർ-വർക്കർ സ്കീം

1.10.3. ക്ലയൻ്റ്-സെർവർ ആശയവിനിമയം

server.c
client.c
ഉദാഹരണം 27a. സി ഭാഷയിൽ ഒരു പൊതു നാമം ഉപയോഗിച്ച് സെർവറും ക്ലയൻ്റും തമ്മിലുള്ള ഡാറ്റ കൈമാറ്റം
server.f
client.f
ഉദാഹരണം 27b. ഫോർട്രാൻ ഭാഷയിൽ പൊതുനാമം ഉപയോഗിച്ച് സെർവറും ക്ലയൻ്റും തമ്മിലുള്ള ഡാറ്റ കൈമാറ്റം

1.10.4. ഒരു പ്രോസസ് അസോസിയേഷൻ നീക്കംചെയ്യുന്നു

1.10.5. സോക്കറ്റ് കമ്മ്യൂണിക്കേഷൻ

1.11. വൺ-വേ ആശയവിനിമയങ്ങൾ

1.11.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.11.2. ഒരു വിൻഡോ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

1.11.3. ഡാറ്റ കൈമാറ്റം

1.11.4. സമന്വയം

ഉദാഹരണം 28a
ഉദാഹരണം 28b
ഉദാഹരണം 29a. C-യിലെ വൺ-വേ കമ്മ്യൂണിക്കേഷൻസ് ഉപയോഗിച്ച് ഒരു റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 29b. ഫോർട്രാനിലെ വൺ-വേ കമ്മ്യൂണിക്കേഷൻസ് ഉപയോഗിച്ച് റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 30a. C-യിലെ വൺ-വേ കമ്മ്യൂണിക്കേഷൻസ് ഉപയോഗിച്ച് ഒരു റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക
ഉദാഹരണം 30 ബി. ഫോർട്രാനിലെ വൺ-വേ കമ്മ്യൂണിക്കേഷൻസ് ഉപയോഗിച്ച് റിംഗ് ടോപ്പോളജി വഴി കൈമാറ്റം ചെയ്യുക

1.12 ബാഹ്യ ഇൻ്റർഫേസുകൾ

1.12.1. പൊതുവായ ചോദ്യങ്ങൾ

1.12.2. സ്റ്റാറ്റസിൽ നിന്നുള്ള വിവരങ്ങൾ

1.12.3. ത്രെഡുകൾ

1.13 സമാന്തര I/O

1.13.1. നിർവചനങ്ങൾ

1.13.2. ഫയലുകളുമായി പ്രവർത്തിക്കുന്നു

1.13.3. ഡാറ്റ ആക്സസ്

ഉദാഹരണം 31a. C ഭാഷയിലുള്ള ഒരു ഫയലിൽ നിന്നുള്ള വായന ബഫർ ചെയ്തു
ഉദാഹരണം 31 ബി. ഫോർട്രാനിലെ ഒരു ഫയലിൽ നിന്നുള്ള വായന ബഫർ ചെയ്തു
ഉദാഹരണം 32a. സി ഭാഷയിലുള്ള ഒരു ഫയലിൽ നിന്നുള്ള കൂട്ടായ വായന
ഉദാഹരണം 32 ബി. ഫോർട്രാനിലെ ഒരു ഫയലിൽ നിന്നുള്ള കൂട്ടായ വായന

1.14 പ്രോസസ്സ് ചെയ്യുന്നതിൽ പിശക്

1.14.1. സാധാരണയായി ലഭ്യമാവുന്നവ

1.14.2. ആശയവിനിമയക്കാരുമായി ബന്ധപ്പെട്ട ഹാൻഡ്‌ലറുകൾ പിശക്

1.14.3. ജാലകവുമായി ബന്ധപ്പെട്ട പിശക് കൈകാര്യം ചെയ്യുന്നവർ

1.14.4. ഫയലുമായി ബന്ധപ്പെട്ട പിശക് കൈകാര്യം ചെയ്യുന്നവർ

1.14.5. അധിക നടപടിക്രമങ്ങൾ

1.14.6. പിശക് കോഡുകളും ക്ലാസുകളും

1.14.7. പിശക് കൈകാര്യം ചെയ്യുന്നവരെ വിളിക്കുന്നു

ഉദാഹരണം 33a. സി ഭാഷയിൽ കൈകാര്യം ചെയ്യുന്നതിൽ പിശക്
ഉദാഹരണം 33 ബി. ഫോർട്രാനിൽ കൈകാര്യം ചെയ്യുന്നതിൽ പിശക്

അധ്യായം 2 ഓപ്പൺഎംപി പാരലൽ പ്രോഗ്രാമിംഗ് ടെക്നോളജി

2.1 ആമുഖം

2.2 അടിസ്ഥാന സങ്കൽപങ്ങൾ

2.2.1. ഒരു പ്രോഗ്രാം കംപൈൽ ചെയ്യുന്നു

ഉദാഹരണം 34a. സിയിലെ സോപാധിക സമാഹാരം
ഉദാഹരണം 34 ബി
ഉദാഹരണം 34c. ഫോർട്രാനിലെ സോപാധിക സമാഹാരം

2.2.2. സമാന്തര പ്രോഗ്രാം മോഡൽ

2.2.3. നിർദ്ദേശങ്ങളും നടപടിക്രമങ്ങളും

2.2.4. പ്രോഗ്രാം എക്സിക്യൂഷൻ

2.2.5. സമയത്തിന്റെ

ഉദാഹരണം 35a. സിയിലെ സിസ്റ്റം ടൈമറുകളിൽ പ്രവർത്തിക്കുന്നു
ഉദാഹരണം 35 ബി. ഫോർട്രാനിലെ സിസ്റ്റം ടൈമറുകളിൽ പ്രവർത്തിക്കുന്നു

2.3 സമാന്തരവും സീരിയൽ ഏരിയകളും

2.3.1. സമാന്തര നിർദ്ദേശം

ഉദാഹരണം 36a. സി ഭാഷയിൽ സമാന്തര മേഖല
ഉദാഹരണം 36 ബി. ഫോർട്രാനിലെ സമാന്തര പ്രദേശം
ഉദാഹരണം 37a. സി ഭാഷയിലെ റിഡക്ഷൻ ഓപ്ഷൻ
ഉദാഹരണം 37 ബി. ഫോർട്രാനിലെ റിഡക്ഷൻ ഓപ്ഷൻ

2.3.2. ചുരുക്കെഴുത്ത്

2.3.3. പരിസ്ഥിതി വേരിയബിളുകളും സഹായ നടപടിക്രമങ്ങളും

ഉദാഹരണം 38a. സി ഭാഷയിൽ Omp_set_num_threads നടപടിക്രമവും num_threads ഓപ്ഷനും
ഉദാഹരണം 38b. ഫോർട്രാൻ ഭാഷയിൽ ഓപ്‌ഷൻ_സെറ്റ്_എണ്ണം_ത്രെഡുകളും ഓപ്‌ഷൻ നം_ത്രെഡുകളും
ഉദാഹരണം 39a. സി ഭാഷയിൽ omp_set_dynamic, omp_get_dynamic നടപടിക്രമങ്ങൾ
ഉദാഹരണം 39 ബി. ഫോർട്രാനിലെ ഓംപ്_സെറ്റ്_ഡൈനാമിക്, ഒംപ്_ഗെറ്റ്_ഡൈനാമിക് നടപടിക്രമങ്ങൾ
ഉദാഹരണം 40a. സിയിലെ സമാന്തര പ്രദേശങ്ങൾ
ഉദാഹരണം 40 ബി. ഫോർട്രാനിലെ സമാന്തര പ്രദേശങ്ങൾ
ഉദാഹരണം 41a. സി ഭാഷയിൽ Omp_in_parallel function
ഉദാഹരണം 41 ബി. ഫോർട്രാൻ ഭാഷയിൽ omp_in_parallel ഫംഗ്‌ഷൻ

2.3.4. ഒരൊറ്റ നിർദ്ദേശം

ഉദാഹരണം 42a. സി ഭാഷയിൽ സിംഗിൾ ഡയറക്‌ടീവും Nowait ഓപ്ഷനും
ഉദാഹരണം 42 ബി. ഫോർട്രാനിൽ സിംഗിൾ ഡയറക്‌ടീവും Nowait ഓപ്ഷനും
ഉദാഹരണം 43a. സി ഭാഷയിൽ കോപ്പി പ്രൈവറ്റ് ഓപ്ഷൻ
ഉദാഹരണം 43b. ഫോർട്രാനിലെ കോപ്പി പ്രൈവറ്റ് ഓപ്ഷൻ

2.3.5. മാസ്റ്റർ നിർദ്ദേശം

ഉദാഹരണം 44a. സി ഭാഷയിൽ മാസ്റ്റർ നിർദ്ദേശം
ഉദാഹരണം 44b. ഫോർട്രാനിലെ പ്രധാന നിർദ്ദേശം

2.4 ഡാറ്റ മോഡൽ

ഉദാഹരണം 45a. സി ഭാഷയിൽ സ്വകാര്യ ഓപ്ഷൻ
ഉദാഹരണം 45 ബി. ഫോർട്രാനിലെ സ്വകാര്യ ഓപ്ഷൻ
ഉദാഹരണം 46a. സി ഭാഷയിൽ പങ്കിട്ട ഓപ്ഷൻ
ഉദാഹരണം 46b. ഫോർട്രാനിലെ പങ്കിട്ട ഓപ്ഷൻ
ഉദാഹരണം 47a. സി ഭാഷയിൽ ആദ്യ സ്വകാര്യ ഓപ്ഷൻ
ഉദാഹരണം 47b. ഫോർട്രാനിലെ ആദ്യ സ്വകാര്യ ഓപ്ഷൻ
ഉദാഹരണം 48a. സി ഭാഷയിൽ ത്രെഡ് പ്രൈവറ്റ് നിർദ്ദേശം
ഉദാഹരണം 48b. ഫോർട്രാനിലെ ത്രെഡ് പ്രൈവറ്റ് നിർദ്ദേശം
ഉദാഹരണം 49a. സി ഭാഷയിൽ കോപ്പിയിൻ ഓപ്ഷൻ
ഉദാഹരണം 49b. ഫോർട്രാനിലെ കോപ്പിഇൻ ഓപ്ഷൻ

2.5 ജോലി വിതരണം

2.5.1. താഴ്ന്ന നിലയിലുള്ള സമാന്തരവൽക്കരണം

ഉദാഹരണം 50a. സി ഭാഷയിൽ omp_get_num_threads ഉം omp_get_thread_num ഉം നടപടിക്രമങ്ങൾ
ഉദാഹരണം 50 ബി. ഫോർട്രാനിലെ omp_get_num_threads, omp_get_thread_num നടപടിക്രമങ്ങൾ

2.5.2. സമാന്തര ലൂപ്പുകൾ

ഉദാഹരണം 51a. സി ഭാഷയിലുള്ള നിർദ്ദേശത്തിനായി
ഉദാഹരണം 51 ബി. ഫോർട്രാനിലെ ചെയ്യേണ്ട നിർദ്ദേശം
ഉദാഹരണം 52a. സി ഭാഷയിൽ ഷെഡ്യൂൾ ഓപ്ഷൻ
ഉദാഹരണം 52b. ഫോർട്രാനിലെ ഷെഡ്യൂൾ ഓപ്ഷൻ
ഉദാഹരണം 53a. സി ഭാഷയിൽ ഷെഡ്യൂൾ ഓപ്ഷൻ

പാരലൽ കംപ്യൂട്ടിംഗിൻ്റെ പഠനവും പ്രത്യേകിച്ച് എംപിഐയുമായി എനിക്ക് അടുത്തിടപഴകാൻ സാധിച്ചു. ഒരുപക്ഷേ ഈ ദിശ ഇന്ന് വളരെ പ്രതീക്ഷ നൽകുന്നതാണ്, അതിനാൽ ഈ പ്രക്രിയയുടെ അടിസ്ഥാനകാര്യങ്ങൾ ഹബ്ബ്ബ്രൌസറുകൾക്ക് കാണിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

അടിസ്ഥാന തത്വങ്ങളും ഉദാഹരണങ്ങളും

എക്‌സ്‌പോണൻഷ്യലിൻ്റെ (ഇ) കണക്കുകൂട്ടൽ ഒരു ഉദാഹരണമായി ഉപയോഗിക്കും. ഇത് കണ്ടെത്തുന്നതിനുള്ള ഓപ്ഷനുകളിലൊന്ന് ടെയ്‌ലർ സീരീസ് ആണ്:
e^x=∑((x^n)/n!), ഇവിടെ n=0 മുതൽ അനന്തത വരെ സംഗ്രഹം സംഭവിക്കുന്നു.

ഈ സൂത്രവാക്യം എളുപ്പത്തിൽ സമാന്തരമാക്കാൻ കഴിയും, കാരണം ആവശ്യമായ സംഖ്യ വ്യക്തിഗത പദങ്ങളുടെ ആകെത്തുകയാണ്, ഇതിന് നന്ദി, ഓരോ പ്രോസസറിനും വ്യക്തിഗത നിബന്ധനകൾ കണക്കാക്കാൻ തുടങ്ങാം.

ഓരോ വ്യക്തിഗത പ്രൊസസറിലും കണക്കാക്കുന്ന പദങ്ങളുടെ എണ്ണം ഇടവേള n ൻ്റെ ദൈർഘ്യത്തെയും കണക്കുകൂട്ടൽ പ്രക്രിയയിൽ പങ്കെടുക്കാൻ കഴിയുന്ന ലഭ്യമായ പ്രോസസറുകളുടെ എണ്ണത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഇടവേളയുടെ ദൈർഘ്യം n=4 ആണെങ്കിൽ, അഞ്ച് പ്രോസസ്സറുകൾ (k=5) കണക്കുകൂട്ടലുകളിൽ ഉൾപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, ആദ്യം മുതൽ നാലാമത്തെ പ്രോസസ്സറുകൾക്ക് ഓരോ ടേം വീതം ലഭിക്കും, അഞ്ചാമത്തേത് ഉപയോഗിക്കില്ല. n=10 ഉം k=5 ഉം ആണെങ്കിൽ, ഓരോ പ്രോസസറിനും കണക്കുകൂട്ടലിനായി രണ്ട് പദങ്ങൾ ലഭിക്കും.

തുടക്കത്തിൽ, MPI_Bcast ബ്രോഡ്‌കാസ്റ്റ് ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ആദ്യ പ്രോസസ്സർ, ഉപയോക്തൃ-നിർദിഷ്ട വേരിയബിളിൻ്റെ മൂല്യം മറ്റുള്ളവർക്ക് അയയ്‌ക്കുന്നു. പൊതുവേ, MPI_Bcast ഫംഗ്‌ഷന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm), ഇവിടെ ബഫർ എന്നത് ഘടകത്തോടുകൂടിയ ബഫറിൻ്റെ വിലാസമാണ്, കൗണ്ട് എന്നത് ഘടകങ്ങളുടെ എണ്ണമാണ്, ഡാറ്റാ ടൈപ്പ് എന്നത് MPI-യിലെ അനുബന്ധ ഡാറ്റാ തരമാണ്, റൂട്ട് ആണ് ഫോർവേഡിംഗ് കൈകാര്യം ചെയ്യുന്ന പ്രധാന പ്രോസസറിൻ്റെ റാങ്ക്, കമ്മ്യൂണിക്കേറ്ററിൻ്റെ പേരാണ് com.
എൻ്റെ കാര്യത്തിൽ, പ്രധാന പ്രോസസറിൻ്റെ പങ്ക്, ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, റാങ്ക് 0 ഉള്ള ആദ്യത്തെ പ്രോസസറായിരിക്കും.

നമ്പർ n വിജയകരമായി അയച്ചുകഴിഞ്ഞാൽ, ഓരോ പ്രോസസറും അതിൻ്റെ നിബന്ധനകൾ കണക്കാക്കാൻ തുടങ്ങും. ഇത് ചെയ്യുന്നതിന്, സൈക്കിളിൻ്റെ ഓരോ ഘട്ടത്തിലും, കണക്കുകൂട്ടലുകളിൽ പങ്കെടുക്കുന്ന പ്രോസസറുകളുടെ എണ്ണത്തിന് തുല്യമായ ഒരു സംഖ്യ ഐ എന്ന നമ്പറിലേക്ക് ചേർക്കും, ഇത് തുടക്കത്തിൽ പ്രോസസറിൻ്റെ റാങ്കിന് തുല്യമാണ്. താഴെപ്പറയുന്ന ഘട്ടങ്ങളിലെ i എന്ന നമ്പർ ഉപയോക്തൃ-നിർദിഷ്ട സംഖ്യ n-നേക്കാൾ കൂടുതലാണെങ്കിൽ, ആ പ്രോസസറിനായുള്ള ലൂപ്പ് എക്സിക്യൂഷൻ നിർത്തും.

സൈക്കിളിൻ്റെ നിർവ്വഹണ സമയത്ത്, നിബന്ധനകൾ ഒരു പ്രത്യേക വേരിയബിളിലേക്ക് ചേർക്കും, അത് പൂർത്തിയാക്കിയ ശേഷം, തത്ഫലമായുണ്ടാകുന്ന തുക പ്രധാന പ്രോസസറിലേക്ക് അയയ്ക്കും. ഇത് ചെയ്യുന്നതിന്, MPI_Reduce റിഡക്ഷൻ ഓപ്പറേഷൻ ഫംഗ്ഷൻ ഉപയോഗിക്കും. പൊതുവേ, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:
int MPI_Reduce(അസാധുവായ *ബഫ്, അസാധുവായ *ഫലം, ഇൻ്റ് കൗണ്ട്, MPI_Datatype ഡാറ്റാടൈപ്പ്, MPI_Op op, int root, MPI_Comm comm)

ഇത് op ഓപ്പറേഷൻ ഉപയോഗിച്ച് ഗ്രൂപ്പിലെ ഓരോ പ്രക്രിയയുടെയും ഇൻപുട്ട് ബഫർ ഘടകങ്ങളെ സംയോജിപ്പിക്കുകയും പ്രോസസ് നമ്പർ റൂട്ടിൻ്റെ ഔട്ട്പുട്ട് ബഫറിലേക്ക് സംയോജിത മൂല്യം തിരികെ നൽകുകയും ചെയ്യുന്നു. അത്തരമൊരു പ്രവർത്തനത്തിൻ്റെ ഫലം ഒരൊറ്റ മൂല്യമായിരിക്കും, അതിനാലാണ് കാസ്റ്റിംഗ് ഫംഗ്ഷന് അതിൻ്റെ പേര് ലഭിച്ചത്.

എല്ലാ പ്രോസസറുകളിലും പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, ആദ്യത്തെ പ്രോസസറിന് ആകെ പദങ്ങളുടെ ആകെ തുക ലഭിക്കും, അത് നമുക്ക് ആവശ്യമായ എക്‌സ്‌പോണൻ്റ് മൂല്യമായിരിക്കും.

എക്‌സ്‌പോണൻ്റ് കണക്കാക്കുന്നതിനുള്ള സമാന്തരവും ക്രമാനുഗതവുമായ രീതികളിൽ, ഫാക്‌ടോറിയൽ കണ്ടെത്താൻ ഒരു ആവർത്തന ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. നിർവ്വഹിക്കുന്ന ടാസ്‌ക്ക് എങ്ങനെ സമാന്തരമാക്കാം എന്നതിനെക്കുറിച്ച് തീരുമാനമെടുക്കുമ്പോൾ, വ്യത്യസ്ത പ്രോസസ്സറുകളിലും ഫാക്‌ടോറിയൽ കണ്ടെത്താനുള്ള ഓപ്ഷൻ ഞാൻ പരിഗണിച്ചു, പക്ഷേ അവസാനം ഈ ഓപ്ഷൻ ഞാൻ യുക്തിരഹിതമായി കണക്കാക്കി.

എക്‌സ്‌പോണൻ്റിൻ്റെ മൂല്യം കണ്ടെത്തുകയാണ് പ്രാഥമിക ദൗത്യം, പ്രോസസ്സറുകൾ ഓരോ പദത്തിൻ്റെയും ഓരോ ഫാക്‌ടോറിയലും വെവ്വേറെ കണക്കാക്കാൻ തുടങ്ങിയാൽ, ഇത് കൃത്യമായ വിപരീത ഫലത്തിലേക്ക് നയിച്ചേക്കാം, അതായത് പ്രകടനത്തിലും കണക്കുകൂട്ടൽ വേഗതയിലും ഗണ്യമായ നഷ്ടം.
ഈ സാഹചര്യത്തിൽ ആശയവിനിമയ പരിതസ്ഥിതിയിൽ വളരെ വലിയ ലോഡ് ഉണ്ടാകും എന്ന വസ്തുത ഇത് വിശദീകരിക്കുന്നു, ഇത് ഇതിനകം തന്നെ പലപ്പോഴും സമാന്തര കമ്പ്യൂട്ടിംഗ് സിസ്റ്റങ്ങളിൽ ഒരു ദുർബലമായ ലിങ്കാണ്. ഓരോ പ്രോസസറിലും ഫാക്‌ടോറിയൽ സ്വകാര്യമായി കണക്കാക്കിയാൽ, ആശയവിനിമയ ലൈനുകളിലെ ലോഡ് വളരെ കുറവായിരിക്കും. സമാന്തരവൽക്കരണം എന്ന ദൗത്യത്തിനും ചിലപ്പോൾ അതിൻ്റെ പരിധികൾ ഉണ്ടായിരിക്കണം എന്നതിൻ്റെ ഉത്തമ ഉദാഹരണമായി ഈ കേസിനെ വിളിക്കാം.

കോഡ് എക്സിക്യൂഷൻ അൽഗോരിതം

1. n എന്ന സംഖ്യയുടെ മൂല്യം വിഷ്വൽ ഷെല്ലിൽ നിന്ന് പ്രോഗ്രാമിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു, അത് ബ്രോഡ്കാസ്റ്റ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് എല്ലാ പ്രോസസ്സറുകളിലേക്കും അയയ്ക്കുന്നു.
2. ആദ്യത്തെ പ്രധാന പ്രോസസ്സർ ആരംഭിക്കുമ്പോൾ, ഒരു ടൈമർ ആരംഭിക്കുന്നു.
3. ഓരോ പ്രോസസറും ഒരു ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നു, അവിടെ സിസ്റ്റത്തിലെ പ്രോസസ്സറുകളുടെ എണ്ണമാണ് ഇൻക്രിമെൻ്റ് മൂല്യം. ലൂപ്പിൻ്റെ ഓരോ ആവർത്തനത്തിലും, ഒരു പദം കണക്കാക്കുകയും അത്തരം പദങ്ങളുടെ ആകെത്തുക ഡ്രോബ്സം വേരിയബിളിൽ സംഭരിക്കുകയും ചെയ്യുന്നു.
4. ലൂപ്പ് പൂർത്തിയായ ശേഷം, MPI_Reduce റിഡക്ഷൻ ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഓരോ പ്രോസസറും അതിൻ്റെ ഡ്രോബ്സം മൂല്യം ഫല വേരിയബിളിലേക്ക് ചേർക്കുന്നു.
5. എല്ലാ പ്രോസസറുകളിലും കണക്കുകൂട്ടലുകൾ പൂർത്തിയാക്കിയ ശേഷം, ആദ്യത്തെ പ്രധാന പ്രോസസ്സർ ടൈമർ നിർത്തുകയും ഫല വേരിയബിളിൻ്റെ ഫലമായ മൂല്യം ഔട്ട്പുട്ട് സ്ട്രീമിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.
6. ഞങ്ങളുടെ ടൈമർ മില്ലിസെക്കൻഡിൽ അളക്കുന്ന സമയ മൂല്യവും ഔട്ട്പുട്ട് സ്ട്രീമിലേക്ക് അയയ്ക്കുന്നു.

കോഡ് ലിസ്റ്റിംഗ്

പ്രോഗ്രാം C++ ൽ എഴുതിയിരിക്കുന്നു, എക്സിക്യൂഷനുള്ള ആർഗ്യുമെൻ്റുകൾ ബാഹ്യ ഷെല്ലിൽ നിന്ന് കടന്നുപോകുമെന്ന് ഞങ്ങൾ അനുമാനിക്കും. കോഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

#ഉൾപ്പെടുന്നു "mpi.h"
#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു
നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു;

ഇരട്ട വസ്തുത (int n)
{
എങ്കിൽ (n==0)
മടക്കം 1;
വേറെ
റിട്ടേൺ n*Fact(n-1);
}

int main(int argc, char *argv)
{
SetConsoleOutputCP(1251);
int n;
int myid;
int numprocs;
int i;
int rc;
നീണ്ട ഇരട്ട ഡ്രോബ്,ഡ്രോബ്സം=0,ഫലം, തുക;
ഇരട്ട ആരംഭസമയം = 0.0;
ഇരട്ട അവസാന സമയം;

N = atoi(argv);

എങ്കിൽ (rc= MPI_Init(&argc, &argv))
{
കട്ട്<< "സ്റ്റാർട്ടപ്പ് പിശക്, നിർവ്വഹണം നിർത്തി" << endl;
MPI_Abort(MPI_COMM_WORLD, rc);
}

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

എങ്കിൽ (myid == 0)
{

ആരംഭസമയം = MPI_Wtime();
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

(i = myid; i<= n; i += numprocs)
{
drob = 1/Fact(i);
drobSum += drob;
}

MPI_Reduce(&drobSum, &ഫലം, 1, MPI_LONG_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
cout.Precision(20);
എങ്കിൽ (myid == 0)
{
കട്ട്<< Result << endl;
endwtime = MPI_Wtime();
കട്ട്<< (endwtime-startwtime)*1000 << endl;
}

MPI_Finalize();
തിരികെ 0;
}

* ഈ സോഴ്സ് കോഡ് സോഴ്സ് കോഡ് ഹൈലൈറ്റർ ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തു.

ഉപസംഹാരം

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