ការណែនាំអំពីបច្ចេកវិទ្យាកម្មវិធីប៉ារ៉ាឡែល (MPI) ។ ក្រុមនិងអ្នកទំនាក់ទំនង។ ប្រតិបត្តិការសកលផ្ទាល់ខ្លួន

ការបើកដំណើរការកម្មវិធី MPI នៅលើចង្កោមកុំព្យូទ័រគឺអាចធ្វើទៅបានតែតាមរយៈប្រព័ន្ធប៉ុណ្ណោះ។ ដំណើរការបាច់កិច្ចការ។ ដើម្បីសម្រួលដល់ការចាប់ផ្តើម និងការដាក់ជួរនៃកម្មវិធីប៉ារ៉ាឡែល វាត្រូវបានផ្តល់ជូន ស្គ្រីបពិសេសមភីរុន។ ឧទាហរណ៍ mpirun -np 20 ./first.exe នឹងចាប់ផ្តើម កម្មវិធីប៉ារ៉ាឡែល first.exe នៅលើ 20 processors, i.e. នៅ 5 ថ្នាំង។ (ថ្នាំងនីមួយៗមានប្រព័ន្ធដំណើរការ dual-core 2) ។ គួរកត់សម្គាល់ថា ដើម្បីបើកដំណើរការម៉ូឌុលដែលអាចប្រតិបត្តិបានដែលមានទីតាំងនៅក្នុងថតបច្ចុប្បន្ន ($pwd) អ្នកត្រូវតែបញ្ជាក់ផ្លូវ “./” មួយចំនួននៃការអនុវត្ត MPI-1 ផ្តល់នូវពាក្យបញ្ជាបើកដំណើរការសម្រាប់កម្មវិធី MPI ដែលមានទម្រង់ មភីរុន<аргументы mpirun><программа><аргументы программы>

ការបំបែកពាក្យបញ្ជាបើកដំណើរការកម្មវិធីចេញពីកម្មវិធីខ្លួនវាផ្តល់នូវភាពបត់បែន ជាពិសេសសម្រាប់ការអនុវត្តបណ្តាញ និងខុសគ្នា។ ការមានយន្តការកេះស្តង់ដារក៏ជួយបង្កើនការចល័តផងដែរ កម្មវិធី MPIមួយជំហានទៀតទៅកាន់បន្ទាត់ពាក្យបញ្ជា និងស្គ្រីបដែលគ្រប់គ្រងពួកវា។ ឧទាហរណ៍ ស្គ្រីបសម្រាប់សំណុំនៃកម្មវិធីសុពលភាពដែលដំណើរការកម្មវិធីរាប់រយអាចជាស្គ្រីបចល័តប្រសិនបើវាត្រូវបានសរសេរដោយប្រើយន្តការចាប់ផ្តើមស្តង់ដារបែបនេះ។ ដើម្បីកុំឱ្យច្រឡំពាក្យបញ្ជា ``ស្តង់ដារ'' ជាមួយពាក្យបញ្ជាដែលមានស្រាប់នៅក្នុងការអនុវត្ត ដែលមិនមែនជាស្តង់ដារ និងមិនអាចចល័តបានក្នុងចំណោមការអនុវត្ត MPI បានកំណត់ mpiexec ជំនួសឱ្យ mpirun ។

ខណៈពេលដែលយន្តការបើកដំណើរការស្តង់ដារធ្វើអោយប្រសើរឡើងនូវលទ្ធភាពប្រើប្រាស់របស់ MPI ជួរនៃបរិស្ថានគឺមានភាពចម្រុះណាស់ (ឧទាហរណ៍ ប្រហែលជាមិនមានចំណុចប្រទាក់ បន្ទាត់ពាក្យបញ្ជា) ដែល MPI មិនអាចកំណត់យន្តការបែបនេះបានទេ។ ជំនួសមកវិញ MPI កំណត់ពាក្យបញ្ជាដំណើរការ mpiexec និងណែនាំ ប៉ុន្តែមិនទាមទារ ជាដំបូន្មានដល់អ្នកអភិវឌ្ឍន៍។ ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើការអនុវត្តផ្តល់នូវពាក្យបញ្ជាដែលហៅថា mpiexec វាត្រូវតែយកទម្រង់ដែលបានពិពណ៌នាខាងក្រោម៖ mpiexec -n <программа>

នឹងយោងទៅតាម យ៉ាងហោចណាស់វិធីមួយដើម្បីរត់<программу>ជាមួយ MPI_COMM_WORLD ដំបូងដែលក្រុមមាន ដំណើរការ។ អាគុយម៉ង់ផ្សេងទៀតចំពោះ mpiexec អាចជាការអនុវត្តអាស្រ័យលើ។

ឧទាហរណ៍ 4.1 កំពុងដំណើរការ 16 ករណីនៃ myprog នៅលើម៉ាស៊ីនបច្ចុប្បន្ន ឬលំនាំដើម៖

mpiexec -n 16 myprog

3. សរសេរកម្មវិធី ការគណនាប៉ារ៉ាឡែលអាំងតេក្រាលច្បាស់លាស់នៃអនុគមន៍ 2*(x+2*x*x/1200.0) ក្នុងចន្លោះពេល។

វិធីសាស្ត្រចតុកោណកែងខាងឆ្វេង

ទ្វេ f (ទ្វេ x)

(ត្រឡប់ 2*(x+2*x*x/1200);) // iskomyi អាំងតេក្រាល

int main (int argc, char **argv)

ស្ថានភាព MPI_Status;

MPI_Init(&argc,&argv);

MPI_Comm_rank(MPI_COMM_WORLD,&rank);

MPI_Comm_size(MPI_COMM_WORLD,&size);

int n=1000,i,d; // 1000 - uzly

អណ្តែត a=0, b=1, h=(b-a)/n,s=0,r=0; //a ខ្ញុំ b -nachalo និង konec otrezka

ប្រសិនបើ (ចំណាត់ថ្នាក់!=size-1) // schitaut vs processy, krome poslednego

(សម្រាប់ (i=rank*d; i<(rank+1)*d; i++) { s=s+h*f(a+i*h); }

MPI_Send(&s,1,MPI_FLOAT,size-1,1,MPI_COMM_WORLD);)

(សម្រាប់ (i=0; i

( MPI_Recv(&s,1,MPI_FLOAT,i,1,MPI_COMM_WORLD, &status); r+=s; ))

MPI_Finalize();)

ស៊ូរ៉ាក់

1. ស្ថាបត្យកម្មអង្គចងចាំដែលបានចែករំលែក និងចែកចាយ។

អង្គចងចាំដែលបានចែករំលែក (DSM - Distributed Shared Memory)

ជាប្រពៃណី ការគណនាចែកចាយគឺផ្អែកលើគំរូបញ្ជូនសារ ដែលក្នុងនោះទិន្នន័យត្រូវបានបញ្ជូនពី processor ទៅ processor ក្នុងទម្រង់ជាសារ។ ការហៅតាមនីតិវិធីពីចម្ងាយគឺពិតជាគំរូដូចគ្នា (ឬជិតបំផុត)។ DSM គឺជាចន្លោះអាសយដ្ឋាននិម្មិតដែលចែករំលែកដោយថ្នាំងទាំងអស់ (ឧបករណ៍ដំណើរការ) នៃប្រព័ន្ធចែកចាយ។ កម្មវិធីចូលប្រើទិន្នន័យនៅក្នុង DSM តាមរបៀបដូចគ្នានឹងពួកគេចូលប្រើទិន្នន័យនៅក្នុងអង្គចងចាំនិម្មិតនៃកុំព្យូទ័រប្រពៃណី។ នៅក្នុងប្រព័ន្ធដែលមាន DSM ទិន្នន័យផ្លាស់ទីរវាងអង្គចងចាំក្នុងស្រុកនៃកុំព្យូទ័រផ្សេងៗគ្នាតាមរបៀបដូចគ្នាដែលវាផ្លាស់ទីរវាង RAM និងអង្គចងចាំខាងក្រៅនៃកុំព្យូទ័រមួយ។ ការកំណត់រចនាសម្ព័ន្ធអង្គចងចាំដែលបានចែកចាយគឺជាបំរែបំរួលនៃអង្គចងចាំដែលបានចែកចាយ។ នៅទីនេះថ្នាំងទាំងអស់ដែលមាន processors មួយឬច្រើនដែលតភ្ជាប់តាមរយៈគ្រោងការណ៍ SMP ប្រើចន្លោះអាសយដ្ឋានទូទៅ។ ភាពខុសគ្នារវាងការកំណត់រចនាសម្ព័ន្ធនេះ និងម៉ាស៊ីនដែលមានអង្គចងចាំចែកចាយគឺថា នៅទីនេះ processor ណាមួយអាចចូលប្រើផ្នែកណាមួយនៃអង្គចងចាំ។ ទោះជាយ៉ាងណាក៏ដោយ ពេលវេលាចូលប្រើសម្រាប់ផ្នែកអង្គចងចាំផ្សេងៗគ្នាប្រែប្រួលសម្រាប់ដំណើរការនីមួយៗ អាស្រ័យលើកន្លែងដែលផ្នែកនេះមានទីតាំងនៅក្នុងចង្កោម។ សម្រាប់ហេតុផលនេះ ការកំណត់រចនាសម្ព័ន្ធបែបនេះក៏ត្រូវបានគេហៅថាម៉ាស៊ីនដែលមានការចូលប្រើសតិមិនឯកសណ្ឋាន (NUMA)។

ភាពខុសគ្នារវាង MPI និង PVM ។

ប្រព័ន្ធ PVM (Parallel Virtual Machine) ត្រូវបានបង្កើតឡើងដើម្បីបញ្ចូលគ្នានូវស្ថានីយការងារបណ្តាញជាច្រើនចូលទៅក្នុងម៉ាស៊ីនកុំព្យូទ័រប៉ារ៉ាឡែលនិម្មិតតែមួយ។ ប្រព័ន្ធនេះគឺជាការបន្ថែមទៅលើប្រព័ន្ធប្រតិបត្តិការ UNIX ហើយត្រូវបានប្រើប្រាស់នៅលើវេទិកាផ្នែករឹងផ្សេងៗ រួមទាំងប្រព័ន្ធស្របគ្នាយ៉ាងច្រើន។ ប្រព័ន្ធសរសេរកម្មវិធីប៉ារ៉ាឡែលទូទៅបំផុតនាពេលបច្ចុប្បន្ននេះគឺផ្អែកលើ MPI (Message Parsing Interface)។ គំនិតរបស់ MPI ដំបូងគឺសាមញ្ញ និងជាក់ស្តែង។ វាពាក់ព័ន្ធនឹងការតំណាងឱ្យកម្មវិធីប៉ារ៉ាឡែលជាសំណុំនៃដំណើរការប្រតិបត្តិប៉ារ៉ាឡែលដែលមានអន្តរកម្មគ្នាទៅវិញទៅមកក្នុងអំឡុងពេលប្រតិបត្តិនៃការផ្ទេរទិន្នន័យដោយប្រើនីតិវិធីទំនាក់ទំនង។ ពួកគេបង្កើតបណ្ណាល័យ MPI ។ ទោះជាយ៉ាងណាក៏ដោយ ការអនុវត្តត្រឹមត្រូវនៃ MPI ដើម្បីគាំទ្រការទំនាក់ទំនងអន្តរដំណើរការបានបង្ហាញថាមានការលំបាកណាស់។ ភាពស្មុគស្មាញនេះត្រូវបានផ្សារភ្ជាប់ជាមួយនឹងតម្រូវការដើម្បីសម្រេចបាននូវការអនុវត្តកម្មវិធីខ្ពស់ តម្រូវការប្រើប្រាស់ធនធានពហុកុំព្យូទ័រជាច្រើន ហើយជាលទ្ធផល ភាពខុសគ្នាដ៏ធំនៅក្នុងការអនុវត្តនីតិវិធីទំនាក់ទំនងអាស្រ័យលើរបៀបដំណើរការទិន្នន័យ។

កំណត់សម្គាល់នេះបង្ហាញពីរបៀបដំឡើង MPI ភ្ជាប់វាទៅ Visual Studio ហើយបន្ទាប់មកប្រើវាជាមួយប៉ារ៉ាម៉ែត្រដែលបានបញ្ជាក់ (ចំនួនថ្នាំងកុំព្យូទ័រ)។ អត្ថបទនេះប្រើ Visual Studio 2015 ព្រោះ... នេះគឺជាសៀវភៅដែលសិស្សរបស់ខ្ញុំមានបញ្ហា (ចំណាំនេះត្រូវបានសរសេរដោយសិស្សសម្រាប់សិស្ស) ប៉ុន្តែការណែនាំប្រហែលជាអាចដំណើរការសម្រាប់កំណែផ្សេងទៀតផងដែរ។

ជំហានទី 1៖
អ្នកត្រូវតែដំឡើង HPC Pack 2008 SDK SP2 (ក្នុងករណីរបស់អ្នកអាចមានកំណែផ្សេងរួចហើយ) ដែលមាននៅលើគេហទំព័រផ្លូវការរបស់ Microsoft ។ សមត្ថភាពប៊ីតនៃកញ្ចប់ និងប្រព័ន្ធត្រូវតែផ្គូផ្គង។

ជំហានទី 2៖
អ្នកត្រូវកំណត់រចនាសម្ព័ន្ធផ្លូវ ដើម្បីធ្វើដូចនេះចូលទៅកាន់ Debug - Properties tab៖

"C:\Program Files\Microsoft HPC Pack 2008 SDK\Include"

នៅក្នុងវាល បញ្ជីឈ្មោះបណ្ណាល័យ៖

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

នៅក្នុងវាលបណ្ណាល័យ ប្រសិនបើមានកំណែ 32 ប៊ីត អ្នកត្រូវបញ្ចូល i386 ជំនួសឱ្យ amd64 ។

Msmpi.lib

ជំហានទី 3:

ដើម្បីកំណត់រចនាសម្ព័ន្ធការបើកដំណើរការ អ្នកត្រូវចូលទៅកាន់ផ្ទាំងបំបាត់កំហុស ហើយក្នុងវាលពាក្យបញ្ជាបញ្ជាក់៖

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

នៅក្នុងវាល អាគុយម៉ង់ពាក្យបញ្ជា បញ្ជាក់ឧទាហរណ៍

N 4 $(TargetPath)

លេខ 4 បង្ហាញពីចំនួនដំណើរការ។

ដើម្បីដំណើរការកម្មវិធីអ្នកត្រូវភ្ជាប់បណ្ណាល័យ

ផ្លូវទៅកាន់គម្រោងមិនត្រូវមាន Cyrillic ទេ។ ប្រសិនបើមានកំហុសកើតឡើង អ្នកអាចប្រើ Microsoft MPI ដែលមាននៅលើគេហទំព័រ Microsoft ។

ដើម្បីធ្វើដូចនេះបន្ទាប់ពីដំឡើងរួចគ្រាន់តែបញ្ចូលផ្លូវក្នុងវាលពាក្យបញ្ជានៃផ្ទាំងបំបាត់កំហុស:

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

ផងដែរ មុនពេលដំណើរការកម្មវិធី កុំភ្លេចបង្ហាញជម្រៅបន្តិចរបស់វា៖

ឧទាហរណ៍នៃការដំណើរការកម្មវិធីជាមួយ MPI:

# រួមបញ្ចូល # រួមបញ្ចូល ដោយប្រើ namespace std; 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 nodes:

ភាពស្របគ្នាជាភាសា C
ឧទាហរណ៍ 3 ខ។ ភាពស្របគ្នានៅ Fortran
ឧទាហរណ៍ 4 ក។ ការកំណត់លក្ខណៈនៃកម្មវិធីកំណត់ម៉ោងប្រព័ន្ធជាភាសា C
ឧទាហរណ៍ 4 ខ។ ការកំណត់លក្ខណៈប្រព័ន្ធកំណត់ម៉ោងនៅក្នុង Fortran

១.៤. ការផ្ញើនិងទទួលសាររវាងដំណើរការដាច់ដោយឡែក

១.៤.១. ប្រតិបត្តិការពីចំណុចមួយទៅចំណុច

១.៤.២. ការផ្ញើនិងទទួលសារជាមួយនឹងការទប់ស្កាត់

ឧទាហរណ៍ 5 ក។ ការផ្លាស់ប្តូរសាររវាងដំណើរការពីរជាភាសា C
ឧទាហរណ៍ 5 ខ។ ការផ្លាស់ប្តូរសាររវាងដំណើរការពីរនៅក្នុង Fortran
ឧទាហរណ៍ 6 ក។ ការផ្លាស់ប្តូរសាររវាងដំណើរការគូ និងសេសនៅក្នុង C
ឧទាហរណ៍ 6 ខ។ ការផ្លាស់ប្តូរសាររវាងដំណើរការគូ និងសេសនៅក្នុង Fortran
ឧទាហរណ៍ ៧ ក. ការបញ្ជូនបន្តទៅដំណើរការដែលមិនមាននៅក្នុង គ
ឧទាហរណ៍ 7 ខ។ ការបញ្ជូនបន្តទៅកាន់ដំណើរការដែលមិនមាននៅក្នុង Fortran
ឧទាហរណ៍ ៨ ក. ការបញ្ជូនទិន្នន័យដែលមានបញ្ហាជាភាសា C
ឧទាហរណ៍ ៨ ខ. ការបញ្ជូនទិន្នន័យដែលមានបញ្ហាជាភាសា Fortran
ឧទាហរណ៍ 9 ក។ ការទទួលបានព័ត៌មានអំពីគុណលក្ខណៈសារជាភាសា C
ឧទាហរណ៍ 9 ខ។ ការទទួលបានព័ត៌មានអំពីគុណលក្ខណៈសារនៅក្នុង Fortran
ឧទាហរណ៍ 10 ក។ និយមន័យនៃភាពយឺតយ៉ាវ និងការបញ្ជូនជាភាសា C
ឧទាហរណ៍ 10 ខ។ ការកំណត់ភាពយឺតយ៉ាវ និងលំហូរចូលនៅក្នុង Fortran

១.៤.៣. ការផ្ញើនិងទទួលសារដោយមិនរារាំង

ឧទាហរណ៍ ១១ ក. ផ្លាស់ប្តូរលើ topology ring ដោយប្រើប្រតិបត្តិការមិនទប់ស្កាត់នៅក្នុង C
ឧទាហរណ៍ ១១ ខ។ ផ្លាស់ប្តូរលើទ្រនិចរង្វង់ដោយប្រើប្រតិបត្តិការមិនទប់ស្កាត់នៅក្នុង Fortran
ឧទាហរណ៍ 12 ក។ គ្រោងការណ៍ទំនាក់ទំនង "មេ - កម្មករ" ជាភាសា C
ឧទាហរណ៍ 12 ខ។ ដ្យាក្រាមទំនាក់ទំនង "មេ - កម្មករ" ជាភាសា Fortran
ឧទាហរណ៍ ១៣ ក. ការផ្ទេរម៉ាទ្រីសជាភាសា C
ឧទាហរណ៍ ១៣ ខ. ការផ្ទេរម៉ាទ្រីសនៅក្នុង Fortran

១.៤.៤. សំណើអន្តរកម្មដែលកំពុងរង់ចាំ

ឧទាហរណ៍ ១៤ ក. គ្រោងការណ៍នៃវិធីសាស្ត្រដដែលៗជាមួយការផ្លាស់ប្តូរតាមទ្រនិចរង្វង់ដោយប្រើសំណួរពន្យារក្នុងភាសា C
ឧទាហរណ៍ 14 ខ។ គ្រោងការណ៍នៃវិធីសាស្រ្តដដែលៗជាមួយនឹងការផ្លាស់ប្តូរលើទ្រូប៉ូឡូញចិញ្ចៀនដោយប្រើសំណួរពន្យាពេលនៅក្នុង Fortran

១.៤.៥. ស្ថានភាពជាប់គាំង

ឧទាហរណ៍ ១៥ ក. ផ្លាស់ប្តូរតាមទ្រនិចនាឡិកាដោយប្រើនីតិវិធី MPI_Sendrecv ជាភាសា C
ឧទាហរណ៍ 15 ខ។ ផ្លាស់ប្តូរតាមទ្រនិចនាឡិកាដោយប្រើនីតិវិធី MPI_SENDRECV នៅក្នុង Fortran

១.៥. អន្តរកម្មនៃដំណើរការសមូហភាព

១.៥.១. បទប្បញ្ញត្តិទូទៅ

១.៥.២. របាំង

ឧទាហរណ៍ ១៦ ក. ការធ្វើសមកាលកម្មរបាំងគំរូជាភាសា C
ឧទាហរណ៍ ១៦ ខ. ការធ្វើសមកាលកម្មរបាំងគំរូនៅក្នុង Fortran

១.៥.៣. ប្រតិបត្តិការផ្ទេរទិន្នន័យរួម

១.៥.៤. ប្រតិបត្តិការសកល

ឧទាហរណ៍ ១៧ ក. ការធ្វើគំរូនៃការបូកសរុបសកលដោយប្រើគ្រោងការណ៍ទ្វេដង និងប្រតិបត្តិការរួម MPI_Reduce ជាភាសា C
ឧទាហរណ៍ ១៧ ខ. ការធ្វើគំរូនៃការបូកសរុបសកលដោយប្រើគ្រោងការណ៍ទ្វេដង និងប្រតិបត្តិការរួម MPI_Reduce នៅក្នុង Fortran

១.៥.៥. ប្រតិបត្តិការសកលផ្ទាល់ខ្លួន

ឧទាហរណ៍ 18 ក។ មុខងារសកលផ្ទាល់ខ្លួនជាភាសា C
ឧទាហរណ៍ 18 ខ។ មុខងារសកលផ្ទាល់ខ្លួននៅក្នុង Fortran

១.៦. ក្រុមនិងអ្នកទំនាក់ទំនង

១.៦.១. បទប្បញ្ញត្តិទូទៅ

១.៦.២. ប្រតិបត្តិការជាមួយក្រុមដំណើរការ

ឧទាហរណ៍ 19 ក។ ធ្វើការជាមួយក្រុមជាភាសា C
ឧទាហរណ៍ 19 ខ។ ធ្វើការជាមួយក្រុមនៅ Fortran

១.៦.៣. ប្រតិបត្តិការជាមួយអ្នកទំនាក់ទំនង

ឧទាហរណ៍ 20 ក។ ទម្លាយអ្នកទំនាក់ទំនងនៅ គ
ឧទាហរណ៍ 20 ខ។ ការបែងចែកអ្នកទំនាក់ទំនងនៅ Fortran
ឧទាហរណ៍ ២១ ក. ដំណើរការរាប់លេខឡើងវិញជាភាសា C
ឧទាហរណ៍ 21 ខ។ ដំណើរការរាប់លេខឡើងវិញនៅ Fortran

១.៦.៤. អ្នកប្រាស្រ័យទាក់ទងគ្នា។

ឧទាហរណ៍ ២២ ក. គ្រោងការណ៍មេ - កម្មករដោយប្រើអន្តរទំនាក់ទំនងជាភាសា C
ឧទាហរណ៍ 22 ខ។ សៀគ្វីបុគ្គលិកមេដោយប្រើ intercommunicator នៅ Fortran

១.៦.៥. គុណលក្ខណៈ

១.៧. និម្មិត topologies

១.៧.១. បទប្បញ្ញត្តិទូទៅ

១.៧.២. តូប៉ូឡូញ Cartesian

១.៧.៣. រចនាសម្ព័ន្ធក្រាហ្វ

ឧទាហរណ៍ ២៣ ក. ដ្យាក្រាមមេ-កម្មករដោយប្រើក្រាហ្វតប៉ូឡូញជាភាសា C
ឧទាហរណ៍ ២៣ ខ. គ្រោងការណ៍មេ - កម្មករដោយប្រើក្រាហ្វិក topology នៅ Fortran

១.៨. ការផ្ញើប្រភេទទិន្នន័យផ្សេងៗគ្នា

១.៨.១. បទប្បញ្ញត្តិទូទៅ

១.៨.២. ប្រភេទទិន្នន័យដែលទទួលបាន

ឧទាហរណ៍ 24 ក។ ការរៀបចំជួរឈរម៉ាទ្រីសឡើងវិញតាមលំដាប់បញ្ច្រាសជាភាសា C
ឧទាហរណ៍ 24 ខ។ ការរៀបចំជួរឈរម៉ាទ្រីសឡើងវិញតាមលំដាប់បញ្ច្រាសនៅក្នុង Fortran

១.៨.៣. ការវេចខ្ចប់ទិន្នន័យ

ឧទាហរណ៍ ២៥ ក. ការផ្ញើទិន្នន័យដែលបានខ្ចប់ជាភាសា C
ឧទាហរណ៍ 25 ខ។ ការផ្ញើទិន្នន័យដែលបានវេចខ្ចប់នៅក្នុង Fortran

១.៩. វត្ថុព័ត៌មាន

១.៩.១. បទប្បញ្ញត្តិទូទៅ

១.៩.២. ធ្វើការជាមួយវត្ថុព័ត៌មាន

១.១០. ការគ្រប់គ្រងដំណើរការថាមវន្ត

១.១០.១. បទប្បញ្ញត្តិទូទៅ

1.10.2.ការបង្កើតដំណើរការ

master.c
ទាសករ.c
ឧទាហរណ៍ 26 ក. គ្រោងការណ៍មេ - កម្មករដោយប្រើដំណើរការបង្កើតជាភាសា C
master.f
ទាសករ.f
ឧទាហរណ៍ 26 ខ។ គ្រោងការណ៍មេ - កម្មករដោយប្រើដំណើរការពងនៅ Fortran

១.១០.៣. ការទំនាក់ទំនងអតិថិជន-ម៉ាស៊ីនមេ

server.c
client.c
ឧទាហរណ៍ ២៧ ក. ការផ្លាស់ប្តូរទិន្នន័យរវាងម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវដោយប្រើឈ្មោះសាធារណៈជាភាសា C
server.f
client.f
ឧទាហរណ៍ 27 ខ។ ការផ្លាស់ប្តូរទិន្នន័យរវាងម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវដោយប្រើឈ្មោះសាធារណៈជាភាសា Fortran

១.១០.៤. ការដកសមាគមដំណើរការ

១.១០.៥. ការទំនាក់ទំនងរន្ធ

១.១១. ការទំនាក់ទំនងផ្លូវតែមួយ

១.១១.១. បទប្បញ្ញត្តិទូទៅ

១.១១.២. ធ្វើការជាមួយបង្អួច

១.១១.៣. ការផ្ទេរទិន្នន័យ

១.១១.៤. ការធ្វើសមកាលកម្ម

ឧទាហរណ៍ 28 ក
ឧទាហរណ៍ 28 ខ
ឧទាហរណ៍ 29 ក. ផ្លាស់ប្តូរលើ topology ring ដោយប្រើទំនាក់ទំនងមួយផ្លូវនៅក្នុង C
ឧទាហរណ៍ 29 ខ។ ផ្លាស់ប្តូរលើទ្រូប៉ូឡូញចិញ្ចៀនដោយប្រើទំនាក់ទំនងមួយផ្លូវនៅ Fortran
ឧទាហរណ៍ 30 ក។ ផ្លាស់ប្តូរលើ topology ring ដោយប្រើទំនាក់ទំនងមួយផ្លូវនៅក្នុង C
ឧទាហរណ៍ 30 ខ។ ផ្លាស់ប្តូរលើទ្រូប៉ូឡូញចិញ្ចៀនដោយប្រើទំនាក់ទំនងមួយផ្លូវនៅ Fortran

១.១២. ចំណុចប្រទាក់ខាងក្រៅ

១.១២.១. សំណួរទូទៅ

១.១២.២. ព័ត៌មានពីស្ថានភាព

១.១២.៣. ខ្សែស្រឡាយ

១.១៣. ប៉ារ៉ាឡែល I/O

១.១៣.១. និយមន័យ

១.១៣.២. ធ្វើការជាមួយឯកសារ

១.១៣.៣. ការចូលប្រើទិន្នន័យ

ឧទាហរណ៍ ៣១ ក. រងការអានពីឯកសារជាភាសា C
ឧទាហរណ៍ 31 ខ។ រងការអានពីឯកសារនៅក្នុង Fortran
ឧទាហរណ៍ ៣២ ក. ការអានសមូហភាពពីឯកសារជាភាសា C
ឧទាហរណ៍ 32 ខ។ ការអានសមូហភាពពីឯកសារនៅក្នុង Fortran

១.១៤. ការដោះស្រាយកំហុស

១.១៤.១. បទប្បញ្ញត្តិទូទៅ

១.១៤.២. ឧបករណ៍ដោះស្រាយកំហុសដែលទាក់ទងនឹងអ្នកទំនាក់ទំនង

១.១៤.៣. ឧបករណ៍ដោះស្រាយកំហុសដែលទាក់ទងនឹងបង្អួច

១.១៤.៤. ឧបករណ៍ដោះស្រាយកំហុសទាក់ទងនឹងឯកសារ

១.១៤.៥. នីតិវិធីបន្ថែម

១.១៤.៦. កូដកំហុស និងថ្នាក់

១.១៤.៧. ការហៅទូរស័ព្ទទៅអ្នកដោះស្រាយកំហុស

ឧទាហរណ៍ 33 ក. កំហុសក្នុងការដោះស្រាយជាភាសា C
ឧទាហរណ៍ 33 ខ។ ការដោះស្រាយកំហុសនៅក្នុង Fortran

ជំពូកទី 2 បច្ចេកវិទ្យាកម្មវិធីប៉ារ៉ាឡែល OpenMP

២.១. សេចក្តីផ្តើម

២.២. គំនិតជាមូលដ្ឋាន

២.២.១. ការចងក្រងកម្មវិធី

ឧទាហរណ៍ ៣៤ ក. ការចងក្រងតាមលក្ខខណ្ឌក្នុង គ
ឧទាហរណ៍ 34 ខ
ឧទាហរណ៍ 34 គ។ ការចងក្រងតាមលក្ខខណ្ឌនៅ Fortran

២.២.២. គំរូកម្មវិធីប៉ារ៉ាឡែល

២.២.៣. សេចក្តីណែនាំ និងនីតិវិធី

២.២.៤. ការអនុវត្តកម្មវិធី

២.២.៥. ពេលវេលា

ឧទាហរណ៍ 35 ក. ធ្វើការជាមួយកម្មវិធីកំណត់ម៉ោងប្រព័ន្ធនៅក្នុង C
ឧទាហរណ៍ 35 ខ។ ធ្វើការជាមួយកម្មវិធីកំណត់ម៉ោងប្រព័ន្ធនៅក្នុង Fortran

២.៣. តំបន់ប៉ារ៉ាឡែលនិងសៀរៀល

២.៣.១. ការណែនាំស្របគ្នា។

ឧទាហរណ៍ ៣៦ ក. តំបន់ប៉ារ៉ាឡែលជាភាសា C
ឧទាហរណ៍ ៣៦ ខ. តំបន់ប៉ារ៉ាឡែលនៅ Fortran
ឧទាហរណ៍ ៣៧ ក. ជម្រើសកាត់បន្ថយជាភាសា C
ឧទាហរណ៍ ៣៧ ខ. ជម្រើសកាត់បន្ថយនៅក្នុង Fortran

២.៣.២. អក្សរកាត់

២.៣.៣. អថេរបរិស្ថាន និងនីតិវិធីជំនួយ

ឧទាហរណ៍ ៣៨ ក. នីតិវិធី Omp_set_num_threads និងជម្រើស num_threads ជាភាសា C
ឧទាហរណ៍ 38 ខ។ ដំណើរការ omp_set_num_threads និងជម្រើស num_threads ជាភាសា Fortran
ឧទាហរណ៍ 39 ក. នីតិវិធី omp_set_dynamic និង omp_get_dynamic ជាភាសា C
ឧទាហរណ៍ 39 ខ។ នីតិវិធី omp_set_dynamic និង omp_get_dynamic នៅក្នុង Fortran
ឧទាហរណ៍ 40 ក។ តំបន់ប៉ារ៉ាឡែល Nested in C
ឧទាហរណ៍ 40 ខ។ តំបន់ប៉ារ៉ាឡែល Nested នៅ Fortran
ឧទាហរណ៍ ៤១ ក. អនុគមន៍ Omp_in_parallel ជាភាសា C
ឧទាហរណ៍ 41 ខ។ មុខងារ omp_in_parallel ជាភាសា Fortran

២.៣.៤. ការណែនាំតែមួយ

ឧទាហរណ៍ 42 ក. ការណែនាំតែមួយ និងជម្រើសឥឡូវនេះជាភាសា C
ឧទាហរណ៍ 42 ខ។ ការណែនាំតែមួយ និងជម្រើសរង់ចាំនៅក្នុង Fortran
ឧទាហរណ៍ ៤៣ ក. ជម្រើសចម្លងឯកជនជាភាសា C
ឧទាហរណ៍ 43 ខ។ ជម្រើសចម្លងឯកជននៅក្នុង Fortran

២.៣.៥. ការណែនាំមេ

ឧទាហរណ៍ 44 ក។ ការណែនាំមេជាភាសា C
ឧទាហរណ៍ 44 ខ។ ការណែនាំមេនៅ Fortran

២.៤. គំរូទិន្នន័យ

ឧទាហរណ៍ 45 ក។ ជម្រើសឯកជនជាភាសា C
ឧទាហរណ៍ 45 ខ។ ជម្រើសឯកជននៅ Fortran
ឧទាហរណ៍ ៤៦ ក. ជម្រើសដែលបានចែករំលែកជាភាសា C
ឧទាហរណ៍ 46 ខ។ ជម្រើសចែករំលែកនៅក្នុង Fortran
ឧទាហរណ៍ 47 ក. ជម្រើសឯកជនដំបូងជាភាសា C
ឧទាហរណ៍ 47 ខ។ ជម្រើសឯកជនដំបូងនៅ Fortran
ឧទាហរណ៍ ៤៨ ក. threadprivate directive ជាភាសា C
ឧទាហរណ៍ ៤៨ ខ. ការណែនាំជាឯកជននៅក្នុង Fortran
ឧទាហរណ៍ 49 ក។ ជម្រើសចម្លងជាភាសា C
ឧទាហរណ៍ 49 ខ។ ជម្រើសចម្លងនៅក្នុង Fortran

២.៥. ការចែកចាយការងារ

២.៥.១. ភាពស្របគ្នាកម្រិតទាប

ឧទាហរណ៍ 50 ក។ នីតិវិធី omp_get_num_threads និង omp_get_thread_num ជាភាសា C
ឧទាហរណ៍ 50 ខ។ នីតិវិធី omp_get_num_threads និង omp_get_thread_num ក្នុង Fortran

២.៥.២. រង្វិលជុំប៉ារ៉ាឡែល

ឧទាហរណ៍ 51 ក។ សម្រាប់ការណែនាំជាភាសា C
ឧទាហរណ៍ 51 ខ។ ការណែនាំធ្វើនៅ Fortran
ឧទាហរណ៍ 52 ក។ ជម្រើសកាលវិភាគជាភាសា C
ឧទាហរណ៍ 52 ខ។ ជម្រើសកាលវិភាគនៅ Fortran
ឧទាហរណ៍ 53 ក. ជម្រើសកាលវិភាគជាភាសា C

មុខងារ MPI មូលដ្ឋាន

បច្ចេកវិទ្យាសរសេរកម្មវិធីទូទៅបំផុតសម្រាប់ប្រព័ន្ធប៉ារ៉ាឡែលដែលមានអង្គចងចាំចែកចាយបច្ចុប្បន្នគឺ MPI (Message Passing Interface) ។ មធ្យោបាយសំខាន់ដែលដំណើរការប៉ារ៉ាឡែលមានអន្តរកម្មគ្នាទៅវិញទៅមកនៅក្នុងប្រព័ន្ធបែបនេះគឺការបញ្ជូនសារ។ សំខាន់ MPI គឺជាបណ្ណាល័យ និងបរិស្ថានប្រតិបត្តិសម្រាប់កម្មវិធីប៉ារ៉ាឡែលនៅក្នុង C ឬ Fortran ។ ការបង្រៀននេះនឹងពិពណ៌នាអំពីឧទាហរណ៍នៃកម្មវិធីនៅក្នុងភាសា C ។

ដំបូង MPI អនុញ្ញាតឱ្យប្រើគំរូការសរសេរកម្មវិធី MIMD (Multiple Instruction Multiple Data) - ស្ទ្រីមជាច្រើននៃការណែនាំ និងទិន្នន័យ ពោលគឺឧ។ រួមបញ្ចូលគ្នានូវកម្មវិធីផ្សេងៗគ្នាជាមួយនឹងទិន្នន័យផ្សេងៗគ្នា។ ប៉ុន្តែការសរសេរកម្មវិធីសម្រាប់គំរូបែបនេះនៅក្នុងការអនុវត្តប្រែទៅជាស្មុគស្មាញពេក ដូច្នេះគំរូ SIMD (Single Program Multiple Data) ត្រូវបានគេប្រើជាធម្មតា - កម្មវិធីមួយ និងស្ទ្រីមទិន្នន័យជាច្រើន។ នៅទីនេះ កម្មវិធីប៉ារ៉ាឡែលត្រូវបានសរសេរតាមរបៀបដែលផ្នែកផ្សេងៗរបស់វាអាចអនុវត្តផ្នែកនៃភារកិច្ចរបស់ពួកគេក្នុងពេលដំណាលគ្នា ដូច្នេះសម្រេចបានភាពស្របគ្នា។ ដោយសារមុខងារ MPI ទាំងអស់មាននៅក្នុងបណ្ណាល័យ នៅពេលចងក្រងកម្មវិធីប៉ារ៉ាឡែល វានឹងចាំបាច់ក្នុងការភ្ជាប់ម៉ូឌុលដែលត្រូវគ្នា។

នៅក្នុង MPI កម្មវិធីប៉ារ៉ាឡែលត្រូវបានកំណត់ថាជាសំណុំនៃដំណើរការដំណើរការក្នុងពេលដំណាលគ្នា។ ដំណើរការអាចត្រូវបានប្រតិបត្តិលើ processors ផ្សេងគ្នា ប៉ុន្តែដំណើរការជាច្រើនក៏អាចមានទីតាំងនៅលើ processor ដូចគ្នា (ក្នុងករណីនេះពួកវាត្រូវបានប្រតិបត្តិក្នុងរបៀបចែករំលែកពេលវេលា)។ នៅពេលដំណើរការកម្មវិធី MPI នៅលើចង្កោម ថ្នាំងនីមួយៗរបស់វានឹងដំណើរការច្បាប់ចម្លងកម្មវិធីរបស់ខ្លួន ដោយអនុវត្តផ្នែកផ្ទាល់ខ្លួននៃភារកិច្ច វាធ្វើតាមថាកម្មវិធីប៉ារ៉ាឡែលគឺជាសំណុំនៃដំណើរការអន្តរកម្ម ដែលនីមួយៗដំណើរការដោយខ្លួនវាផ្ទាល់។ ចន្លោះអាសយដ្ឋាន។ ក្នុងករណីធ្ងន់ធ្ងរ ខួរក្បាលតែមួយអាចត្រូវបានប្រើដើម្បីប្រតិបត្តិកម្មវិធីប៉ារ៉ាឡែល - តាមក្បួនវិធីសាស្រ្តនេះត្រូវបានប្រើដើម្បីពិនិត្យភាពត្រឹមត្រូវនៃកម្មវិធីប៉ារ៉ាឡែលដំបូង។

ចំនួនដំណើរការ និងចំនួន processors ដែលប្រើត្រូវបានកំណត់នៅពេលកម្មវិធីប៉ារ៉ាឡែលត្រូវបានចាប់ផ្តើមដោយប្រើបរិយាកាសប្រតិបត្តិកម្មវិធី MPI ហើយមិនអាចផ្លាស់ប្តូរកំឡុងពេលគណនាបានទេ។ ដំណើរការទាំងអស់នៃកម្មវិធីត្រូវបានរាប់ជាលំដាប់ពី 0 ដល់ np-1 ដែល np គឺជាចំនួនដំណើរការសរុប។ លេខដំណើរការត្រូវបានគេហៅថាលំដាប់ដំណើរការ។

ដំណើរការប៉ារ៉ាឡែលមានអន្តរកម្មគ្នាទៅវិញទៅមកដោយការផ្ញើសារ។ មានវិធីសាស្រ្តបញ្ជូនពីរប្រភេទ (ពួកវាត្រូវបានគេហៅថាទំនាក់ទំនង) - សមូហភាព និងចំណុចមួយទៅចំណុច។ ជាមួយនឹងការទំនាក់ទំនងសមូហភាព ដំណើរការមួយបញ្ជូនព័ត៌មានចាំបាច់ក្នុងពេលដំណាលគ្នាទៅកាន់ក្រុមទាំងមូលនៃដំណើរការនេះ ក៏មានករណីទូទៅបន្ថែមទៀតនៅពេលដែលនៅក្នុងក្រុមនៃដំណើរការព័ត៌មានត្រូវបានផ្ទេរពីដំណើរការនីមួយៗទៅនីមួយៗ។ ការប្រាស្រ័យទាក់ទងដ៏សាមញ្ញគឺជាការទំនាក់ទំនងពីចំណុចមួយទៅចំណុច ដែលដំណើរការមួយបញ្ជូនព័ត៌មានទៅមួយផ្សេងទៀត ឬពួកគេទាំងពីរផ្លាស់ប្តូរព័ត៌មាន។ មុខងារទំនាក់ទំនងគឺជាមុខងារចម្បងរបស់បណ្ណាល័យ MPI ។ លើសពីនេះ មុខងារដែលត្រូវការគឺមុខងារចាប់ផ្តើម និងបញ្ចប់ MPI - MPI_Init និង MPI_Finalize ។ MPI_Init គួរតែត្រូវបានហៅនៅដើមដំបូងនៃកម្មវិធី ហើយ MPI_Finalize នៅចុងបញ្ចប់។ មុខងារ MPI ផ្សេងទៀតទាំងអស់ត្រូវតែត្រូវបានហៅរវាងមុខងារទាំងពីរនេះ។

តើដំណើរការដឹងពីផ្នែកណានៃការគណនាដែលវាគួរអនុវត្តដោយរបៀបណា? ដំណើរការនីមួយៗដែលដំណើរការលើចង្កោមមានលេខរៀងៗខ្លួន - ចំណាត់ថ្នាក់។ នៅពេលដែលដំណើរការមួយដឹងពីចំណាត់ថ្នាក់របស់វា និងចំនួនសរុបនៃដំណើរការ វាអាចកំណត់ចំណែកនៃការងាររបស់វា។ ចំពោះគោលបំណងនេះមានមុខងារពិសេសនៅក្នុង MPI - MPI_Comm_rank និង MPI_Comm_size ។ MPI_Comm_rank ត្រឡប់ចំណាត់ថ្នាក់ចំនួនគត់នៃដំណើរការដែលហៅថាវា ហើយ MPI_Comm_size ត្រឡប់ចំនួនសរុបនៃដំណើរការដែលកំពុងដំណើរការ។

ដំណើរការនៃកម្មវិធីអ្នកប្រើប្រាស់ប៉ារ៉ាឡែលដែលកំពុងត្រូវបានបំបាត់កំហុសត្រូវបានបញ្ចូលគ្នាជាក្រុម។ នៅក្នុង MPI អ្នកទំនាក់ទំនងត្រូវបានគេយល់ថាជាវត្ថុសេវាកម្មដែលបង្កើតជាពិសេសដែលរួមបញ្ចូលគ្នានូវក្រុមនៃដំណើរការ និងប៉ារ៉ាម៉ែត្របន្ថែមមួយចំនួន (បរិបទ) ដែលប្រើនៅពេលអនុវត្តប្រតិបត្តិការផ្ទេរទិន្នន័យ។ ឧបករណ៍ទំនាក់ទំនងដែលត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិនៅពេលកម្មវិធីចាប់ផ្តើម និងរួមបញ្ចូលដំណើរការទាំងអស់នៅលើចង្កោមត្រូវបានគេហៅថា MPI_COMM_WORLD ។ កំឡុងពេលគណនា ក្រុមដំណើរការថ្មី និងអ្នកទំនាក់ទំនងអាចត្រូវបានបង្កើត ហើយក្រុមដែលមានស្រាប់នៃដំណើរការ និងអ្នកទំនាក់ទំនងអាចត្រូវបានលុប។ ដំណើរការដូចគ្នាអាចជារបស់ក្រុមផ្សេងគ្នា និងអ្នកទំនាក់ទំនង។ ប្រតិបត្តិការសមូហភាពត្រូវបានអនុវត្តក្នុងពេលដំណាលគ្នាចំពោះដំណើរការទំនាក់ទំនងទាំងអស់ ដូច្នេះសម្រាប់ពួកគេ ប៉ារ៉ាម៉ែត្រមួយក្នុងចំណោមប៉ារ៉ាម៉ែត្រនឹងតែងតែជាអ្នកទំនាក់ទំនង។

នៅពេលអនុវត្តប្រតិបត្តិការបញ្ជូនសារនៅក្នុងមុខងារ MPI វាចាំបាច់ត្រូវបញ្ជាក់ប្រភេទទិន្នន័យដែលត្រូវបានផ្ញើ។ MPI មានសំណុំទិន្នន័យមូលដ្ឋានដ៏ធំមួយដោយផ្អែកលើប្រភេទទិន្នន័យស្តង់ដារនៃភាសា C លើសពីនេះ អ្នកសរសេរកម្មវិធីអាចបង្កើតប្រភេទទិន្នន័យផ្ទាល់ខ្លួនរបស់គាត់ដោយប្រើមុខងារ MPI ពិសេស។ ខាងក្រោមនេះគឺជាតារាងផែនទីសម្រាប់ប្រភេទទិន្នន័យមូលដ្ឋាន។

ថេរ MPI	ប្រភេទទិន្នន័យភាសា C
MPI_INT	បានចុះហត្ថលេខា int
MPI_UNSignED	មិនបានចុះហត្ថលេខា int
MPI_SHORT	បានចុះហត្ថលេខា int
MPI_LONG	បានចុះហត្ថលេខាយូរ int
MPI_UNSIGNED_SHORT	មិនបានចុះហត្ថលេខា int
MPI_UNSIGNED_LONG	unsigned long int
MPI_FLOAT	អណ្តែត
MPI_DoubLE	ទ្វេ
MPI_LONG_DoubLE	វែងទ្វេ
MPI_UNSIGNED_CHAR	តួអក្សរដែលមិនបានចុះហត្ថលេខា
MPI_CHAR	បានចុះហត្ថលេខា char

ឧទាហរណ៍នៃការបើកដំណើរការបណ្ណាល័យ MPI៖ ចូលសិស្ស ពាក្យសម្ងាត់ s304។

# រួមបញ្ចូល

int មេ (int argc, char * argv)

/* ការចាប់ផ្តើម MPI */

MPI_Init(&argc, &argv);

// ទទួលបានចំណាត់ថ្នាក់ដំណើរការ */

MPI_Comm_rank (MPI_COMM_WORLD, &rank);

/* ទទួលបានចំនួនសរុបនៃដំណើរការ*/

MPI_Comm_size (MPI_COMM_WORLD, &size);

printf("ជំរាបសួរពិភពលោកពីដំណើរការ %d នៃ %d\n", ចំណាត់ថ្នាក់, ទំហំ);

/* MPI ពេញលេញ*/

Compiler និង Linker ត្រូវបានប្រើសម្រាប់ការចងក្រង។ បន្ទាត់ពាក្យបញ្ជា mpicc ។ (សូមមើល mpicc….-ជំនួយ)

ដំណើរការដែលកំពុងដំណើរការនីមួយៗគួរតែបង្ហាញចំណាត់ថ្នាក់របស់វា និងចំនួនសរុបនៃដំណើរការ។ ចូរយើងព្យាយាមចងក្រង និងដំណើរការកម្មវិធីនេះ។

$ mpicc hello.c –o hello.o

$ mpicc hello.o –o ជំរាបសួរ

ឯកសារសួស្តីនឹងជាឯកសារដែលអាចប្រតិបត្តិបានឧទាហរណ៍។ អ្នកអាចដំណើរការវានៅលើម៉ាស៊ីនមួយ ហើយឃើញថាចំនួន processor នឹងស្មើនឹង 1 ហើយចំណាត់ថ្នាក់ដំណើរការនឹងមាន 0:

$./សួស្តី

ជំរាបសួរពិភពលោកពីដំណើរការ 0 នៃ 1

នៅពេលធ្វើការលើម៉ាស៊ីនមេ ពាក្យបញ្ជាត្រូវបានប្រើដើម្បីចាប់ផ្តើម មភីរុន . វាមានអាគុយម៉ង់សំខាន់ពីរ - ឈ្មោះឯកសារដែលមានអាសយដ្ឋានថ្នាំង និងចំនួនថ្នាំងដែលកម្មវិធីនឹងត្រូវបានដំណើរការ។

$ mpirun n0-6 –v ស្វាគមន៍

ជំរាបសួរពិភពលោកពីដំណើរការ 0 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 3 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 5 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 4 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 2 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 6 នៃ 7

ជំរាបសួរពិភពលោកពីដំណើរការ 1 នៃ 7

កម្មវិធីនឹងដំណើរការលើ 7 nodes (រួមទាំង server) ហើយអាស័យដ្ឋានរបស់ថ្នាំងទាំងនេះស្ថិតនៅក្នុង ឯកសារម៉ាស៊ីន។ការបោះពុម្ពលើអេក្រង់ត្រូវបានអនុវត្តដោយដំណើរការខុសពីលំដាប់របស់ពួកគេ។ នេះគឺដោយសារតែការដំណើរការនៃដំណើរការមិនត្រូវបានធ្វើសមកាលកម្ម ប៉ុន្តែ MPI មានមុខងារពិសេសសម្រាប់ធ្វើសមកាលកម្មដំណើរការ។

កម្មវិធីសាមញ្ញបំផុតមិនមានមុខងារផ្ទេរសារទេ។ នៅក្នុងបញ្ហាជាក់ស្តែង ដំណើរការត្រូវមានទំនាក់ទំនងគ្នាទៅវិញទៅមក។ តាមធម្មជាតិ ពេលវេលាត្រូវបានចំណាយក្នុងការបញ្ជូនសារ ដែលកាត់បន្ថយមេគុណប៉ារ៉ាឡែលនៃកិច្ចការ។ ល្បឿននៃចំណុចប្រទាក់ផ្ទេរសារកាន់តែខ្ពស់ (ឧទាហរណ៍ 10Mb/sec Ethernet និង Gigabit Ethernet) តម្លៃផ្ទេរទិន្នន័យនឹងកាន់តែទាប។ ដោយសារតែ ពេលវេលាសម្រាប់ការផ្លាស់ប្តូរទិន្នន័យរវាងដំណើរការគឺច្រើន (តាមលំដាប់លំដោយ) យូរជាងពេលចូលដំណើរការទៅកាន់អង្គចងចាំរបស់វា ការចែកចាយការងាររវាងដំណើរការគួរតែជា 'មិនច្របូកច្របល់' ហើយការផ្ទេរទិន្នន័យដែលមិនចាំបាច់គួរតែត្រូវបានជៀសវាង។

ក្នុងចំណោមបញ្ហានៃការវិភាគលេខ មានបញ្ហាជាច្រើនដែលភាពស្របគ្នាគឺជាក់ស្តែង។ ឧទាហរណ៍ ការរួមបញ្ចូលលេខពិតជាមកលើការគណនា (ជាច្រើន) នៃអនុគមន៍អាំងតេក្រាល (ដែលត្រូវបានប្រគល់ឱ្យដំណើរការបុគ្គលដោយធម្មជាតិ) ខណៈពេលដែលដំណើរការចម្បងគ្រប់គ្រងដំណើរការគណនា (កំណត់យុទ្ធសាស្ត្រសម្រាប់ចែកចាយចំណុចរួមបញ្ចូលក្នុងចំណោមដំណើរការ និងប្រមូលផលបូកមួយផ្នែក) . បញ្ហានៃការស្វែងរក និងតម្រៀបក្នុងបញ្ជីលីនេអ៊ែរ ជាលេខ ការស្វែងរកឫសនៃមុខងារ ការស្វែងរក extrema នៃអនុគមន៍នៃអថេរជាច្រើន ការគណនាស៊េរី និងផ្សេងទៀតមានភាពស្របគ្នាស្រដៀងគ្នា។ នៅក្នុងមន្ទីរពិសោធន៍នេះ យើងនឹងពិនិត្យមើលក្បួនដោះស្រាយប៉ារ៉ាឡែលពីរសម្រាប់គណនាπ។

ការគណនាលេខ π ដោយវិធីសាស្ត្ររួមបញ្ចូលលេខ

វាត្រូវបានគេស្គាល់ថា

ជំនួសការគណនានៃអាំងតេក្រាលជាមួយនឹងការបូកសរុបកំណត់យើងមាន ដែលជាកន្លែងដែល n គឺជាចំនួននៃផ្នែកបូកកំឡុងពេលរួមបញ្ចូលលេខ។ តំបន់នៃផ្នែកនីមួយៗត្រូវបានគណនាជាផលិតផលនៃទទឹងនៃ 'បន្ទះ' និងតម្លៃនៃមុខងារនៅកណ្តាល 'បន្ទះ' បន្ទាប់មកតំបន់ទាំងនោះត្រូវបានសង្ខេបដោយដំណើរការសំខាន់ (ក្រឡាចត្រង្គឯកសណ្ឋានគឺ បានប្រើ) ។

ជាក់ស្តែង ការធ្វើប៉ារ៉ាឡែលបញ្ហានេះងាយស្រួលធ្វើ ប្រសិនបើដំណើរការនីមួយៗគណនាផលបូកផ្នែករបស់វា ហើយបន្ទាប់មកបញ្ជូនលទ្ធផលនៃការគណនាទៅដំណើរការមេ។ តើខ្ញុំអាចជៀសវាងការគណនាដដែលៗនៅទីនេះដោយរបៀបណា? ដំណើរការត្រូវតែដឹងពីចំណាត់ថ្នាក់របស់វា ចំនួនសរុបនៃដំណើរការ និងចំនួនចន្លោះពេលដែលផ្នែកនឹងត្រូវបានបែងចែក (ចន្លោះពេលកាន់តែច្រើន ភាពត្រឹមត្រូវកាន់តែខ្ពស់)។ បន្ទាប់មកនៅក្នុងវដ្ដពី 1 ដល់ចំនួនចន្លោះពេល ដំណើរការនឹងគណនាផ្ទៃនៃបន្ទះនៅលើចន្លោះ i-th ហើយបន្ទាប់មកផ្លាស់ទីមិនទៅចន្លោះ i+1 បន្ទាប់ ប៉ុន្តែទៅចន្លោះ i+m ដែល m ជាចំនួនដំណើរការ។ ដូចដែលយើងដឹងរួចមកហើយថាមានមុខងារដើម្បីទទួលបានចំណាត់ថ្នាក់និងចំនួនសរុបនៃដំណើរការ MPI_Comm_rank និង MPI_Comm_size . មុនពេលចាប់ផ្តើមការគណនា ដំណើរការចម្បងត្រូវតែបញ្ជូនចំនួនចន្លោះពេលទៅអ្នកផ្សេង ហើយបន្ទាប់ពីការគណនា ប្រមូលផលបូកផ្នែកដែលបានទទួលពីពួកគេ ហើយបូកសរុបវានៅក្នុង MPI នេះត្រូវបានអនុវត្តដោយការបញ្ជូនសារ។ វាងាយស្រួលប្រើមុខងារអន្តរកម្មរួមនៅទីនេះ ដើម្បីផ្ញើសារ MPI_Bcast ដែលបញ្ជូនទិន្នន័យដូចគ្នាពីដំណើរការមួយទៅគ្រប់ដំណើរការផ្សេងទៀត។ ដើម្បីប្រមូលចំនួនផ្នែកមានជម្រើស 2 - អ្នកអាចប្រើ MPI_Gather ដែលប្រមូលទិន្នន័យពីដំណើរការទាំងអស់ ហើយផ្តល់ឱ្យវាទៅមួយ (អារេនៃធាតុ m ត្រូវបានទទួល ដែល m ជាចំនួននៃដំណើរការ) ឬ MPI_កាត់បន្ថយ . MPI_កាត់បន្ថយ ធ្វើសកម្មភាពស្រដៀងគ្នា MPI_Gather - ប្រមូលទិន្នន័យពីដំណើរការទាំងអស់ ហើយផ្តល់ឱ្យវាទៅមួយ ប៉ុន្តែមិនមែនក្នុងទម្រង់នៃអារេនោះទេ ប៉ុន្តែជាដំបូងធ្វើប្រតិបត្តិការជាក់លាក់មួយរវាងធាតុនៃអារេ ឧទាហរណ៍ ការបូកសរុប ហើយបន្ទាប់មកផ្តល់ធាតុមួយ។ សម្រាប់កិច្ចការនេះ វាហាក់ដូចជាងាយស្រួលប្រើជាង MPI_កាត់បន្ថយ . អត្ថបទកម្មវិធីត្រូវបានផ្តល់ឱ្យខាងក្រោម

# រួមបញ្ចូល "mpi.h"

# រួមបញ្ចូល

ទ្វេ f (ទ្វេដង a)

ត្រឡប់ (4.0 / (1.0 + a*a));

int main (int argc, char *argv)

int n, myid, numprocs, i;

PI25DT ទ្វេ = 3.141592653589793238462643;

mypi ទ្វេ, pi, h, បូក, x;

ពីរដង startwtime, endwtime;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

startwtime = MPI_Wtime();

MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

h = 1.0 / (ទ្វេ) n;

សម្រាប់ (i = myid + 1; i<= n; i += numprocs)

x = h * ((ទ្វេ)i - 0.5);

MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

printf("pi គឺប្រហែល %16f, កំហុសគឺ %16f\n",

pi, fabs (pi - PI25DT));

endwtime = MPI_Wtime();

printf("ម៉ោងនាឡិកាជញ្ជាំង = %f\n",

ចុងម៉ោង - ចាប់ផ្តើមម៉ោង);

សូមក្រឡេកមើលការហៅមុខងារឱ្យកាន់តែដិតដល់ MPI_Bcast និង MPI_កាត់បន្ថយ :

MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD) – មាតិកានៃអថេរ n និងធាតុមួយនៃប្រភេទ MPI_INT ពីដំណើរការដែលមានចំណាត់ថ្នាក់ 0 ត្រូវបានបញ្ជូនទៅដំណើរការផ្សេងទៀតទាំងអស់ (MPI_COMM_WORLD – ដំណើរការទាំងអស់នៅក្នុងឧបករណ៍ទំនាក់ទំនង) ទៅក្នុងអថេរដូចគ្នា n . បន្ទាប់ពីការហៅទូរសព្ទនេះ ដំណើរការនីមួយៗនឹងដឹងពីចំនួនសរុបនៃចន្លោះពេល។ នៅចុងបញ្ចប់នៃការគណនា MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD) បូកសរុប (ប៉ារ៉ាម៉ែត្រ MPI_SUM) តម្លៃពីអថេរ mypi នៃប្រភេទ MPI_DOUBLE នៃដំណើរការនីមួយៗ ហើយសរសេរលទ្ធផលទៅដំណើរការនីមួយៗ។ អថេរ pi ជាមួយចំណាត់ថ្នាក់ 0. ដើម្បីវាស់ពេលវេលាគណនា ដំណើរការចម្បងប្រើមុខងារ MPI_Wtime ។

MPI_Wtime ();

MPI_Wtimeត្រឡប់ចំនួនវិនាទីក្នុងទម្រង់អណ្តែតទឹក ដែលតំណាងឱ្យពេលវេលាដែលបានកន្លងផុតទៅចាប់តាំងពីកម្មវិធីចាប់ផ្តើម។

ការគណនាលេខ π ដោយប្រើវិធីសាស្ត្រ Monte Carlo

ដើម្បីគណនាតម្លៃ π អ្នកអាចប្រើវិធីសាស្ត្រ 'បាញ់' ។ នៅពេលអនុវត្តចំពោះករណីនេះ វិធីសាស្ត្រមាននៅក្នុងការបង្កើតចំណុចដែលចែកចាយស្មើៗគ្នាលើផ្ទៃពីរវិមាត្រ និងការកំណត់។

តម្លៃនៃ π គណនាតាមវិធីនេះគឺប្រហាក់ប្រហែល; វិធីសាស្រ្តស្រដៀងគ្នានេះត្រូវបានប្រើនៅពេលដែលវាពិបាកក្នុងការធ្វើការប៉ាន់ប្រមាណជាលេខត្រឹមត្រូវ។

ក្បួនដោះស្រាយប៉ារ៉ាឡែលសម្រាប់គណនាលេខ π ដោយប្រើវិធីនេះគឺមានច្រើនវិធីស្រដៀងនឹងក្បួនដោះស្រាយមុនដែលយើងបានពិចារណា។ ដើម្បីបង្កើតលេខចៃដន្យ អ្នកត្រូវប្រើមុខងារ srand ដែលកំណត់ចំណាត់ថ្នាក់នៃដំណើរការជាអាគុយម៉ង់ (sequence seed) ដូច្នេះដំណើរការនីមួយៗនឹងមានលំដាប់រៀងៗខ្លួន។

# រួមបញ្ចូល

void srand (គ្រាប់ពូជដែលមិនបានចុះហត្ថលេខា);

អនុគមន៍ srand() កំណត់ចំនួនគ្រាប់ពូជសម្រាប់លំដាប់ដែលបង្កើតដោយអនុគមន៍ rand() ។

# រួមបញ្ចូល

int rand (ចាត់ទុកជាមោឃៈ);

អនុគមន៍ rand() បង្កើតលំដាប់នៃលេខ pseudorandom ។ រាល់ពេលដែលមុខងារត្រូវបានហៅ ចំនួនគត់រវាងសូន្យ និងតម្លៃ RAND_MAX ត្រូវបានត្រឡប់។

ដើម្បីប្រមូលលទ្ធផលនៅទីនេះ វាក៏ងាយស្រួលប្រើ MPI_Reduce ជាមួយនឹងប្រតិបត្តិការបូកសរុប (MPI_SUM) បន្ទាប់មកចែកផលបូកលទ្ធផលដោយចំនួន processor ទទួលបានមធ្យមនព្វន្ធ។

int MPI_Reduce(void* sendbuf, void* recvbuf, int count,

ប្រភេទទិន្នន័យ MPI_Datatype, MPI_Op op, int root, MPI_Comm comm);

ប៉ារ៉ាម៉ែត្រ៖

អាសយដ្ឋាន sendbuf នៃសតិបណ្ដោះអាសន្នផ្ញើ

អាសយដ្ឋាន recvbuf នៃសតិបណ្ដោះអាសន្នទទួល

ប្រតិបត្តិការកាត់បន្ថយ

comm អ្នកទំនាក់ទំនង

int MPI_Bcast(ចាត់ទុកជាមោឃៈ *សតិបណ្ដោះអាសន្ន, ចំនួន int, ប្រភេទទិន្នន័យ MPI_Datatype, int root,

MPI_Comm comm);

ប៉ារ៉ាម៉ែត្រ៖

អាសយដ្ឋានសតិបណ្ដោះអាសន្ននៃការផ្ញើ/ទទួលសតិបណ្ដោះអាសន្ន

រាប់ចំនួនធាតុនៅក្នុងសតិបណ្ដោះអាសន្នផ្ញើ (ចំនួនគត់)

datatype ប្រភេទទិន្នន័យនៃការបញ្ជូនធាតុសតិបណ្ដោះអាសន្ន

លេខដំណើរការសំខាន់របស់ root (ចំនួនគត់)

comm អ្នកទំនាក់ទំនង

លំហាត់ប្រាណ: ដោយអនុលោមតាមលេខជម្រើស ចងក្រង និងដំណើរការកម្មវិធីប៉ារ៉ាឡែលដែលគណនាលេខ π ដោយប្រើក្បួនដោះស្រាយដែលបានផ្តល់ឱ្យ។

ដំណើរការភារកិច្ចនៅលើថ្នាំងមួយ និងពីចង្កោមលើចំនួនថ្នាំងដែលបានបញ្ជាក់។ វាយតម្លៃពេលវេលាគណនា ភាពត្រឹមត្រូវ និងមេគុណប៉ារ៉ាឡែល Amdahl ដោយគិតគូរពីការពន្យាពេលបណ្តាញតាមទ្រឹស្តី និងផ្អែកលើលទ្ធផលនៃការងារ។

ជម្រើសភារកិច្ច

ជម្រើសលេខ	ក្បួនដោះស្រាយ	ចំនួនឧបករណ៍ដំណើរការ	ចំនួននៃការធ្វើម្តងទៀតនៅលើ processor នីមួយៗ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ
	ការរួមបញ្ចូលលេខ
	ម៉ុងតេ ខាឡូ

· សេចក្តីថ្លែងការណ៍អំពីបញ្ហា ជម្រើស។

· អត្ថបទនៃកម្មវិធីប៉ារ៉ាឡែលជាភាសា C យោងទៅតាមកិច្ចការ។

· លទ្ធផលនៃការដំណើរការកម្មវិធីនៅលើថ្នាំងមួយ ពេលវេលាប្រតិបត្តិ t i លទ្ធផលគណនា កំហុស។

· លទ្ធផលនៃការដំណើរការកម្មវិធីនៅលើម៉ាស៊ីនមេ ពេលវេលាប្រតិបត្តិ លទ្ធផលគណនា កំហុស។

· ពិពណ៌នាអំពីក្បួនដោះស្រាយប៉ារ៉ាឡែល លំហូរព័ត៌មានកំឡុងពេលដំណើរការកម្មវិធី និងការផ្ទុកអង្គចងចាំឃ្លាំងសម្ងាត់ថ្នាំង។ គណនាមេគុណ Amdahl - K j ដោយផ្អែកលើលទ្ធផលនៃកម្មវិធី។

· ដោយពិចារណាលើលទ្ធផលនៃការងាររបស់សិស្សមួយក្រុម បង្កើតអ៊ីស្តូក្រាមនៃការពឹងផ្អែករបស់ K j, t i លើចំនួន processors ដែលចូលរួមក្នុងការគណនា។

ការបង្រៀន

នៅក្នុងការប្រកាសនេះ យើងនឹងនិយាយអំពីការរៀបចំការផ្លាស់ប្តូរទិន្នន័យដោយប្រើ MPI ដោយប្រើឧទាហរណ៍នៃ Intel MPI Library ។ យើងគិតថាព័ត៌មាននេះនឹងមានការចាប់អារម្មណ៍សម្រាប់អ្នកដែលចង់ស្គាល់ពីវិស័យកុំព្យូទ័រដែលមានប្រសិទ្ធភាពខ្ពស់ស្របគ្នាក្នុងការអនុវត្តជាក់ស្តែង។

យើងនឹងផ្តល់នូវការពិពណ៌នាសង្ខេបអំពីរបៀបដែលការផ្លាស់ប្តូរទិន្នន័យត្រូវបានរៀបចំនៅក្នុងកម្មវិធីប៉ារ៉ាឡែលដោយផ្អែកលើ MPI ក៏ដូចជាតំណភ្ជាប់ទៅកាន់ប្រភពខាងក្រៅជាមួយនឹងការពិពណ៌នាលម្អិតបន្ថែមទៀត។ នៅក្នុងផ្នែកជាក់ស្តែង អ្នកនឹងឃើញការពិពណ៌នាអំពីដំណាក់កាលទាំងអស់នៃការបង្កើតកម្មវិធី "Hello World" MPI demo ដោយចាប់ផ្តើមពីការរៀបចំបរិយាកាសចាំបាច់ និងបញ្ចប់ដោយការបើកដំណើរការកម្មវិធីដោយខ្លួនឯង។

MPI (ចំណុចប្រទាក់បញ្ជូនសារ)

MPI គឺជាសារឆ្លងកាត់ចំណុចប្រទាក់រវាងដំណើរការដែលបំពេញភារកិច្ចដូចគ្នា។ វាត្រូវបានបម្រុងទុកជាចម្បងសម្រាប់ប្រព័ន្ធអង្គចងចាំដែលបានចែកចាយ (MPP) ដែលផ្ទុយទៅនឹងឧទាហរណ៍ OpenMP ។ ប្រព័ន្ធចែកចាយ (ចង្កោម) ជាក្បួនគឺជាសំណុំនៃថ្នាំងកុំព្យូទ័រដែលតភ្ជាប់ដោយបណ្តាញទំនាក់ទំនងដែលមានប្រសិទ្ធភាពខ្ពស់ (ឧទាហរណ៍ InfiniBand) ។

MPI គឺជាស្តង់ដារចំណុចប្រទាក់ទិន្នន័យទូទៅបំផុតសម្រាប់ការសរសេរកម្មវិធីប៉ារ៉ាឡែល។ ស្តង់ដារ MPI ត្រូវបានអនុវត្តដោយវេទិកា MPI ។ មានការអនុវត្ត MPI សម្រាប់វេទិកាទំនើប ប្រព័ន្ធប្រតិបត្តិការ និងភាសា។ MPI ត្រូវបានគេប្រើយ៉ាងទូលំទូលាយក្នុងការដោះស្រាយបញ្ហាផ្សេងៗក្នុងរូបវិទ្យាគណនា ឱសថ វិទ្យាសាស្ត្រសម្ភារ ពន្ធុវិទ្យា និងវិស័យចំណេះដឹងផ្សេងទៀត។

តាមទស្សនៈ MPI កម្មវិធីប៉ារ៉ាឡែលគឺជាសំណុំនៃដំណើរការដែលដំណើរការលើថ្នាំងកុំព្យូទ័រផ្សេងៗគ្នា។ ដំណើរការនីមួយៗត្រូវបានបង្កើតចេញពីកូដកម្មវិធីដូចគ្នា។

ប្រតិបត្តិការសំខាន់នៅក្នុង MPI គឺការបញ្ជូនសារ។ MPI អនុវត្តលំនាំទំនាក់ទំនងជាមូលដ្ឋានស្ទើរតែទាំងអស់៖ ចំណុចមួយទៅចំណុច សមូហភាព និងម្ខាង។

ធ្វើការជាមួយ MPI

សូមក្រឡេកមើលឧទាហរណ៍ផ្ទាល់អំពីរបៀបដែលកម្មវិធី MPI ធម្មតាត្រូវបានរៀបចំឡើង។ ជាកម្មវិធីសាកល្បង សូមយកឧទាហរណ៍កូដប្រភពដែលភ្ជាប់មកជាមួយ Intel MPI Library ។ មុនពេលដំណើរការកម្មវិធី MPI ដំបូងរបស់យើង យើងត្រូវរៀបចំ និងរៀបចំបរិយាកាសការងារសម្រាប់ការពិសោធន៍។

រៀបចំបរិស្ថានចង្កោម

សម្រាប់ការពិសោធន៍ យើងនឹងត្រូវការថ្នាំងកុំព្យូទ័រមួយគូ (និយមជាមួយនឹងលក្ខណៈស្រដៀងគ្នា)។ ប្រសិនបើអ្នកមិនមានម៉ាស៊ីនមេពីរនៅនឹងដៃទេ អ្នកអាចប្រើប្រាស់សេវាកម្មពពកបានជានិច្ច។

សម្រាប់ការបង្ហាញ ខ្ញុំបានជ្រើសរើសសេវាកម្ម Amazon Elastic Compute Cloud (Amazon EC2)។ Amazon ផ្តល់ឱ្យអ្នកប្រើប្រាស់ថ្មីនូវឆ្នាំសាកល្បងឥតគិតថ្លៃនៃម៉ាស៊ីនមេកម្រិតចូល។

ការធ្វើការជាមួយ Amazon EC2 គឺវិចារណញាណ។ ប្រសិនបើអ្នកមានចម្ងល់ផ្សេងៗ អ្នកអាចមើលឯកសារលម្អិត (ជាភាសាអង់គ្លេស)។ ប្រសិនបើចង់បាន អ្នកអាចប្រើប្រាស់សេវាកម្មស្រដៀងគ្នាផ្សេងទៀត។

យើងបង្កើតម៉ាស៊ីនមេនិម្មិតពីរដែលកំពុងដំណើរការ។ នៅក្នុងកុងសូលគ្រប់គ្រងសូមជ្រើសរើស ម៉ាស៊ីនមេនិម្មិត EC2 នៅក្នុងពពកបន្ទាប់មក បើកដំណើរការឧទាហរណ៍("Instance" មានន័យថាជាឧទាហរណ៍ម៉ាស៊ីនមេនិម្មិត)។

ជំហានបន្ទាប់គឺជ្រើសរើសប្រព័ន្ធប្រតិបត្តិការ។ Intel MPI Library គាំទ្រទាំង Linux និង Windows ។ សម្រាប់អ្នកស្គាល់គ្នាដំបូងជាមួយ MPI យើងនឹងជ្រើសរើស OS Linux ។ ជ្រើសរើស Red Hat Enterprise Linux 6.6 64 ប៊ីតឬ SLES11.3/12.0.
ជ្រើសរើស ប្រភេទវត្ថុ(ប្រភេទម៉ាស៊ីនមេ) ។ សម្រាប់ការពិសោធន៍ t2.micro (1 vCPUs, 2.5 GHz, Intel Xeon processor family, 1 GiB of RAM) គឺសមរម្យសម្រាប់យើង។ ក្នុងនាមជាអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះថ្មីៗនេះ ខ្ញុំអាចប្រើប្រភេទនេះដោយឥតគិតថ្លៃ ដោយសម្គាល់ថា "Free tier eligible"។ យើងកំណត់ ចំនួនករណី: 2 (ចំនួនម៉ាស៊ីនមេនិម្មិត)។

បន្ទាប់ពីសេវាកម្មជំរុញឱ្យយើងដំណើរការ បើកដំណើរការករណី(បានកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនមេនិម្មិត) យើងរក្សាទុកសោ SSH ដែលនឹងត្រូវការដើម្បីទំនាក់ទំនងជាមួយម៉ាស៊ីនមេនិម្មិតពីខាងក្រៅ។ ស្ថានភាពនៃម៉ាស៊ីនមេនិម្មិត និងអាសយដ្ឋាន IP សម្រាប់ការទំនាក់ទំនងជាមួយម៉ាស៊ីនមេកុំព្យូទ័រក្នុងតំបន់អាចត្រូវបានត្រួតពិនិត្យនៅក្នុងកុងសូលគ្រប់គ្រង។

ចំណុចសំខាន់៖ នៅក្នុងការកំណត់ បណ្តាញ និងសន្តិសុខ / ក្រុមសន្តិសុខយើងត្រូវបង្កើតច្បាប់ដែលនឹងបើកច្រកសម្រាប់ការតភ្ជាប់ TCP - វាត្រូវការសម្រាប់អ្នកគ្រប់គ្រងដំណើរការ MPI ។ ច្បាប់អាចមើលទៅដូចនេះ៖