รู้เบื้องต้นเกี่ยวกับเทคโนโลยีการเขียนโปรแกรมแบบขนาน (MPI) กลุ่มและผู้สื่อสาร การดำเนินงานทั่วโลกที่กำหนดเอง

การเปิดตัวแอปพลิเคชัน MPI บนคลัสเตอร์คอมพิวเตอร์สามารถทำได้ผ่านระบบเท่านั้น การประมวลผลเป็นชุดงาน เพื่อให้การเปิดและการเข้าคิวโปรแกรมแบบขนานง่ายขึ้น สคริปต์พิเศษเอ็มไพรุน. ตัวอย่างเช่น mpirun -np 20 ./first.exe จะเปิดขึ้นมา โปรแกรมคู่ขนาน first.exe บนโปรเซสเซอร์ 20 ตัวเช่น ที่ 5 โหนด (แต่ละโหนดมีโปรเซสเซอร์ดูอัลคอร์ 2 ตัว) เป็นที่น่าสังเกตว่าในการเปิดโมดูลที่ปฏิบัติการได้ซึ่งอยู่ในไดเร็กทอรีปัจจุบัน ($pwd) คุณต้องระบุเส้นทาง“ ./” อย่างชัดเจน การใช้งาน MPI-1 จำนวนหนึ่งจะมีคำสั่งเรียกใช้สำหรับโปรแกรม MPI ซึ่งมีรูปแบบ mpirun<аргументы mpirun><программа><аргументы программы>

การแยกคำสั่งเรียกใช้โปรแกรมออกจากตัวโปรแกรมเองทำให้เกิดความยืดหยุ่น โดยเฉพาะสำหรับการใช้งานแบบเครือข่ายและแบบต่างกัน การมีกลไกไกปืนมาตรฐานยังช่วยเพิ่มความสะดวกในการพกพาอีกด้วย โปรแกรม MPIก้าวไปอีกขั้นหนึ่งสำหรับบรรทัดคำสั่งและสคริปต์ที่ควบคุม ตัวอย่างเช่น สคริปต์สำหรับชุดโปรแกรมตรวจสอบความถูกต้องที่รันโปรแกรมหลายร้อยโปรแกรมอาจเป็นสคริปต์แบบพกพาได้หากเขียนโดยใช้กลไกการเรียกใช้งานมาตรฐานดังกล่าว เพื่อไม่ให้สับสนระหว่างคำสั่ง ``มาตรฐาน'' กับคำสั่งที่มีอยู่ในทางปฏิบัติ ซึ่งไม่ใช่มาตรฐานและไม่สามารถพกพาได้ในการใช้งาน MPI จึงกำหนด mpiexec แทน mpirun

แม้ว่ากลไกการเปิดตัวที่เป็นมาตรฐานจะปรับปรุงการใช้งาน MPI แต่ช่วงของสภาพแวดล้อมก็มีความหลากหลายมาก (เช่น อาจไม่มีอินเทอร์เฟซด้วยซ้ำ บรรทัดคำสั่ง) ที่ MPI ไม่สามารถกำหนดกลไกดังกล่าวได้ MPI จะกำหนดคำสั่งรัน mpiexec แทน และแนะนำแต่ไม่จำเป็นต้องใช้เพื่อเป็นคำแนะนำสำหรับนักพัฒนา อย่างไรก็ตาม หากการใช้งานมีคำสั่งที่เรียกว่า mpiexec จะต้องอยู่ในรูปแบบที่อธิบายไว้ด้านล่าง: mpiexec -n <программа>

จะเป็นไปตาม อย่างน้อยวิธีหนึ่งในการวิ่ง<программу>ด้วย MPI_COMM_WORLD เริ่มต้นซึ่งมีกลุ่มประกอบด้วย กระบวนการ อาร์กิวเมนต์อื่น ๆ ของ mpiexec อาจขึ้นอยู่กับการใช้งาน

ตัวอย่าง 4.1 การรัน myprog 16 อินสแตนซ์บนเครื่องปัจจุบันหรือเครื่องเริ่มต้น:

mpiexec -n 16 myprog

3. เขียนโปรแกรม การคำนวณแบบขนานอินทิกรัลที่แน่นอนของฟังก์ชัน 2*(x+2*x*x/1200.0) ในช่วงเวลา

วิธีสี่เหลี่ยมผืนผ้าซ้าย

ดับเบิ้ลเอฟ(ดับเบิ้ล x)

(ส่งคืน 2*(x+2*x*x/1200);) // iskomyi integrated

int หลัก (int argc, ถ่าน ** argv)

สถานะ MPI_สถานะ;

MPI_Init(&argc,&argv);

MPI_Comm_rank(MPI_COMM_WORLD,&อันดับ);

MPI_Comm_size(MPI_COMM_WORLD,&ขนาด);

int n=1,000,i,d; // 1,000 - อุซซี่

ลอย a=0, b=1, h=(b-a)/n,s=0,r=0; //a ฉัน b -nachalo และ konec otrezka

if (rank!=size-1) // schitaut vse processy, krome poslednego

( สำหรับ (i=rank*d; i<(rank+1)*d; i++) { s=s+h*f(a+i*h); }

MPI_Send(&s,1,MPI_FLOAT,ขนาด-1,1,MPI_COMM_WORLD);)

( สำหรับ (i=0; i

( MPI_Recv(&s,1,MPI_FLOAT,i,1,MPI_COMM_WORLD, &สถานะ); r+=s; ) )

MPI_สรุป();)

สุรักษ์

1- สถาปัตยกรรมหน่วยความจำแบบแบ่งใช้และแบบกระจาย

หน่วยความจำที่ใช้ร่วมกันแบบกระจาย (DSM - หน่วยความจำที่ใช้ร่วมกันแบบกระจาย)

ตามเนื้อผ้า การคำนวณแบบกระจายจะขึ้นอยู่กับรูปแบบการส่งข้อความ ซึ่งข้อมูลจะถูกส่งผ่านจากตัวประมวลผลไปยังตัวประมวลผลในรูปแบบของข้อความ การเรียกขั้นตอนระยะไกลจริง ๆ แล้วเป็นรุ่นเดียวกัน (หรือใกล้เคียงกันมาก) DSM คือพื้นที่ที่อยู่เสมือนที่ใช้ร่วมกันโดยโหนด (โปรเซสเซอร์) ทั้งหมดของระบบแบบกระจาย โปรแกรมเข้าถึงข้อมูลใน DSM ในลักษณะเดียวกับการเข้าถึงข้อมูลในหน่วยความจำเสมือนของคอมพิวเตอร์แบบดั้งเดิม ในระบบที่มี DSM ข้อมูลจะย้ายระหว่างหน่วยความจำในเครื่องของคอมพิวเตอร์เครื่องต่างๆ ในลักษณะเดียวกับที่ย้ายระหว่าง RAM และหน่วยความจำภายนอกของคอมพิวเตอร์เครื่องหนึ่ง การกำหนดค่าหน่วยความจำที่ใช้ร่วมกันแบบกระจายเป็นรูปแบบหนึ่งของหน่วยความจำแบบกระจาย ในที่นี้ โหนดทั้งหมดซึ่งประกอบด้วยโปรเซสเซอร์ตั้งแต่หนึ่งตัวขึ้นไปที่เชื่อมต่อผ่านโครงร่าง SMP จะใช้พื้นที่ที่อยู่ทั่วไป ความแตกต่างระหว่างการกำหนดค่านี้กับเครื่องที่มีหน่วยความจำแบบกระจายก็คือ โปรเซสเซอร์ใดๆ ในที่นี้สามารถเข้าถึงส่วนใดๆ ของหน่วยความจำได้ อย่างไรก็ตาม เวลาในการเข้าถึงสำหรับส่วนหน่วยความจำที่แตกต่างกันจะแตกต่างกันไปสำหรับโปรเซสเซอร์แต่ละตัว ขึ้นอยู่กับตำแหน่งของส่วนนั้นในคลัสเตอร์ ด้วยเหตุนี้ การกำหนดค่าดังกล่าวจึงเรียกว่าเครื่องที่มีการเข้าถึงหน่วยความจำที่ไม่สม่ำเสมอ (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:

“C:\Program Files\Microsoft HPC Pack 2008 SDK\Include”

ในฟิลด์ Library Directories:

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

ในช่องไลบรารี หากมีเวอร์ชัน 32 บิต คุณต้องป้อน i386 แทน amd64

Msmpi.lib

ขั้นตอนที่ 3:

ในการกำหนดค่าการเปิดตัว คุณต้องไปที่แท็บ Debugging และในช่อง Command ให้ระบุ:

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

ในฟิลด์ Command Arguments ให้ระบุ เช่น

N 4 $(เส้นทางเป้าหมาย)

หมายเลข 4 ระบุจำนวนกระบวนการ

ในการรันโปรแกรมคุณต้องเชื่อมต่อไลบรารี

เส้นทางไปยังโครงการต้องไม่มีอักษรซีริลลิก หากเกิดข้อผิดพลาด คุณสามารถใช้ Microsoft MPI ได้จากเว็บไซต์ Microsoft

ในการดำเนินการนี้หลังการติดตั้ง เพียงป้อนเส้นทางในช่องคำสั่งของแท็บการดีบัก:

“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 โหนด:

การขนานในภาษาซี
ตัวอย่างที่ 3b การขนานใน Fortran
ตัวอย่าง 4ก การกำหนดคุณสมบัติของตัวจับเวลาระบบในภาษา C
ตัวอย่าง 4b การกำหนดคุณสมบัติตัวจับเวลาของระบบใน Fortran

1.4. การส่งและรับข้อความระหว่างกระบวนการที่แยกจากกัน

1.4.1. การดำเนินงานแบบจุดต่อจุด

1.4.2. การส่งและรับข้อความด้วยการบล็อค

ตัวอย่างที่ 5ก การแลกเปลี่ยนข้อความระหว่างสองกระบวนการในภาษา C
ตัวอย่างที่ 5b แลกเปลี่ยนข้อความระหว่างสองกระบวนการใน Fortran
ตัวอย่างที่ 6ก การแลกเปลี่ยนข้อความระหว่างกระบวนการคู่และคี่ใน C
ตัวอย่างที่ 6b การแลกเปลี่ยนข้อความระหว่างกระบวนการคู่และคี่ใน Fortran
ตัวอย่าง 7a การส่งต่อไปยังกระบวนการที่ไม่มีอยู่ใน C
ตัวอย่างที่ 7b การส่งต่อไปยังกระบวนการที่ไม่มีอยู่ใน Fortran
ตัวอย่างที่ 8ก ข้อมูลบัฟเฟอร์ที่ส่งเป็นภาษา C
ตัวอย่างที่ 8b ข้อมูลบัฟเฟอร์ที่ส่งเป็นภาษา Fortran
ตัวอย่างที่ 9ก การรับข้อมูลเกี่ยวกับคุณลักษณะข้อความในภาษา C
ตัวอย่างที่ 9ข การรับข้อมูลเกี่ยวกับคุณลักษณะข้อความใน Fortran
ตัวอย่าง 10a คำจำกัดความของเวลาแฝงและปริมาณงานในภาษา C
ตัวอย่างที่ 10b กำหนดเวลาแฝงและปริมาณงานใน Fortran

1.4.3. การส่งและรับข้อความโดยไม่ปิดกั้น

ตัวอย่างที่ 11a แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การดำเนินการที่ไม่ปิดกั้นใน C
ตัวอย่างที่ 11b แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การดำเนินการที่ไม่ปิดกั้นใน Fortran
ตัวอย่าง 12a รูปแบบการสื่อสาร "อาจารย์ - คนงาน" ในภาษาซี
ตัวอย่างที่ 12b แผนภาพการสื่อสาร "ต้นแบบ - คนงาน" ในภาษา Fortran
ตัวอย่างที่ 13ก การขนย้ายเมทริกซ์ในภาษาซี
ตัวอย่างที่ 13b การย้ายเมทริกซ์ใน Fortran

1.4.4. คำขอโต้ตอบที่รอดำเนินการ

ตัวอย่างที่ 14ก แผนผังของวิธีการวนซ้ำที่มีการแลกเปลี่ยนตามโทโพโลยีแบบวงแหวนโดยใช้การสืบค้นแบบเลื่อนออกไปในภาษา C
ตัวอย่างที่ 14ข แผนผังของวิธีการวนซ้ำที่มีการแลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การสืบค้นแบบเลื่อนเวลาใน Fortran

1.4.5. สถานการณ์การหยุดชะงัก

ตัวอย่างที่ 15ก แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้ขั้นตอน MPI_Sendrecv ในภาษา C
ตัวอย่างที่ 15b แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้ขั้นตอน MPI_SENDRECV ใน Fortran

1.5. การโต้ตอบกระบวนการโดยรวม

1.5.1. บทบัญญัติทั่วไป

1.5.2. สิ่งกีดขวาง

ตัวอย่างที่ 16ก การสร้างแบบจำลองการซิงโครไนซ์สิ่งกีดขวางในภาษา C
ตัวอย่างที่ 16b การสร้างแบบจำลองการซิงโครไนซ์สิ่งกีดขวางใน Fortran

1.5.3. การดำเนินการถ่ายโอนข้อมูลแบบรวม

1.5.4. การดำเนินงานทั่วโลก

ตัวอย่างที่ 17ก การสร้างแบบจำลองการรวมทั่วโลกโดยใช้รูปแบบสองเท่าและการดำเนินการรวม MPI_Reduce ในภาษา C
ตัวอย่างที่ 17b การสร้างแบบจำลองการรวมทั่วโลกโดยใช้รูปแบบสองเท่าและการดำเนินการรวม MPI_Reduce ใน Fortran

1.5.5. การดำเนินงานทั่วโลกที่กำหนดเอง

ตัวอย่างที่ 18ก ฟังก์ชันส่วนกลางที่กำหนดเองในภาษา C
ตัวอย่างที่ 18b ฟังก์ชันส่วนกลางที่กำหนดเองใน Fortran

1.6. กลุ่มและผู้สื่อสาร

1.6.1. บทบัญญัติทั่วไป

1.6.2. การดำเนินการกับกลุ่มกระบวนการ

ตัวอย่างที่ 19ก การทำงานร่วมกับกลุ่มภาษาซี
ตัวอย่างที่ 19ข การทำงานร่วมกับกลุ่มใน Fortran

1.6.3. การดำเนินการกับผู้สื่อสาร

ตัวอย่าง 20a ทำลายเครื่องมือสื่อสารใน C
ตัวอย่าง 20ข การแบ่งพาร์ติชันเครื่องมือสื่อสารใน Fortran
ตัวอย่างที่ 21ก การเรียงลำดับกระบวนการในภาษา C
ตัวอย่างที่ 21ข การกำหนดหมายเลขกระบวนการใหม่ใน Fortran

1.6.4. ผู้สื่อสารระหว่างกัน

ตัวอย่าง 22a โครงการผู้ปฏิบัติงานหลักโดยใช้เครื่องสื่อสารภายในในภาษา C
ตัวอย่าง 22ข วงจรผู้ปฏิบัติงานหลักโดยใช้เครื่องสื่อสารภายในใน Fortran

1.6.5. คุณลักษณะ

1.7. โทโพโลยีเสมือน

1.7.1. บทบัญญัติทั่วไป

1.7.2. โทโพโลยีคาร์ทีเซียน

1.7.3. โทโพโลยีกราฟ

ตัวอย่างที่ 23ก แผนภาพผู้ปฏิบัติงานหลักโดยใช้โทโพโลยีกราฟในภาษา C
ตัวอย่างที่ 23b โครงการผู้ปฏิบัติงานหลักโดยใช้โทโพโลยีกราฟใน Fortran

1.8. การส่งข้อมูลประเภทต่างๆ

1.8.1. บทบัญญัติทั่วไป

1.8.2. ชนิดข้อมูลที่ได้รับ

ตัวอย่างที่ 24ก การจัดเรียงคอลัมน์เมทริกซ์ใหม่ในลำดับย้อนกลับในภาษา C
ตัวอย่างที่ 24b การจัดเรียงคอลัมน์เมทริกซ์ใหม่ในลำดับย้อนกลับใน Fortran

1.8.3. การบรรจุข้อมูล

ตัวอย่างที่ 25ก ส่งข้อมูลแพ็กเป็นภาษา C
ตัวอย่างที่ 25b การส่งข้อมูลที่แพ็คใน Fortran

1.9. วัตถุข้อมูล

1.9.1. บทบัญญัติทั่วไป

1.9.2. การทำงานกับวัตถุข้อมูล

1.10. การควบคุมกระบวนการแบบไดนามิก

1.10.1. บทบัญญัติทั่วไป

1.10.2.การสร้างกระบวนการ

มาสเตอร์.ซี
ทาส.ซี
ตัวอย่างที่ 26ก โครงการผู้ปฏิบัติงานหลักโดยใช้กระบวนการวางไข่ในภาษา C
มาสเตอร์.เอฟ
ทาส.f
ตัวอย่างที่ 26ข โครงการผู้ปฏิบัติงานหลักโดยใช้กระบวนการวางไข่ใน Fortran

1.10.3. การสื่อสารระหว่างไคลเอนต์และเซิร์ฟเวอร์

เซิร์ฟเวอร์.ซี
ลูกค้า.ค
ตัวอย่างที่ 27ก การแลกเปลี่ยนข้อมูลระหว่างเซิร์ฟเวอร์และไคลเอนต์โดยใช้ชื่อสาธารณะในภาษา C
เซิร์ฟเวอร์.f
ลูกค้า.f
ตัวอย่างที่ 27ข การแลกเปลี่ยนข้อมูลระหว่างเซิร์ฟเวอร์และไคลเอนต์โดยใช้ชื่อสาธารณะในภาษา Fortran

1.10.4. การลบการเชื่อมโยงกระบวนการ

1.10.5. การสื่อสารซ็อกเก็ต

1.11. การสื่อสารทางเดียว

1.11.1. บทบัญญัติทั่วไป

1.11.2. ทำงานกับหน้าต่าง

1.11.3. การถ่ายโอนข้อมูล

1.11.4. การซิงโครไนซ์

ตัวอย่างที่ 28ก
ตัวอย่างที่ 28ข
ตัวอย่างที่ 29ก แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การสื่อสารทางเดียวใน C
ตัวอย่างที่ 29ข แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การสื่อสารทางเดียวใน Fortran
ตัวอย่างที่ 30a แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การสื่อสารทางเดียวใน C
ตัวอย่าง 30ข แลกเปลี่ยนผ่านโทโพโลยีแบบวงแหวนโดยใช้การสื่อสารทางเดียวใน Fortran

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ข บัฟเฟอร์การอ่านจากไฟล์ใน Fortran
ตัวอย่างที่ 32ก การอ่านรวมจากไฟล์ในภาษา C
ตัวอย่าง 32b การอ่านโดยรวมจากไฟล์ใน Fortran

1.14. เกิดข้อผิดพลาดในการประมวลผล

1.14.1. บทบัญญัติทั่วไป

1.14.2. ตัวจัดการข้อผิดพลาดที่เกี่ยวข้องกับเครื่องมือสื่อสาร

1.14.3. ตัวจัดการข้อผิดพลาดที่เกี่ยวข้องกับหน้าต่าง

1.14.4. ตัวจัดการข้อผิดพลาดที่เกี่ยวข้องกับไฟล์

1.14.5. ขั้นตอนเพิ่มเติม

1.14.6. รหัสข้อผิดพลาดและคลาส

1.14.7. กำลังเรียกตัวจัดการข้อผิดพลาด

ตัวอย่างที่ 33ก เกิดข้อผิดพลาดในการจัดการในภาษา C
ตัวอย่างที่ 33b การจัดการข้อผิดพลาดใน Fortran

บทที่ 2 เทคโนโลยีการเขียนโปรแกรมแบบขนาน OpenMP

2.1. การแนะนำ

2.2. แนวคิดพื้นฐาน

2.2.1. การรวบรวมโปรแกรม

ตัวอย่างที่ 34ก การรวบรวมแบบมีเงื่อนไขใน C
ตัวอย่างที่ 34b
ตัวอย่างที่ 34ค การรวบรวมแบบมีเงื่อนไขใน Fortran

2.2.2. รูปแบบโปรแกรมแบบขนาน

2.2.3. คำสั่งและขั้นตอนปฏิบัติ

2.2.4. การทำงานของโปรแกรม

2.2.5. เวลา

ตัวอย่างที่ 35a การทำงานกับตัวจับเวลาระบบใน C
ตัวอย่างที่ 35b การทำงานกับตัวจับเวลาระบบใน Fortran

2.3. พื้นที่ขนานและอนุกรม

2.3.1. คำสั่งคู่ขนาน

ตัวอย่างที่ 36ก ขอบเขตคู่ขนานในภาษา C
ตัวอย่างที่ 36b ภูมิภาคขนานใน Fortran
ตัวอย่างที่ 37ก ตัวเลือกการลดในภาษา C
ตัวอย่างที่ 37ข ตัวเลือกการลดใน Fortran

2.3.2. สัญกรณ์ชวเลข

2.3.3. ตัวแปรสภาพแวดล้อมและขั้นตอนตัวช่วย

ตัวอย่างที่ 38ก ขั้นตอน 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
ตัวอย่าง 40a ขอบเขตขนานที่ซ้อนกันใน C
ตัวอย่าง 40b ขอบเขตขนานที่ซ้อนกันใน Fortran
ตัวอย่างที่ 41ก ฟังก์ชัน Omp_in_parallel ในภาษา C
ตัวอย่างที่ 41b ฟังก์ชัน omp_in_parallel ในภาษา Fortran

2.3.4. คำสั่งเดียว

ตัวอย่าง 42a คำสั่งเดียวและตัวเลือก nowait ในภาษา C
ตัวอย่าง 42ข คำสั่งเดียวและตัวเลือก nowait ใน Fortran
ตัวอย่างที่ 43ก ตัวเลือก Copyprivate ในภาษา C
ตัวอย่างที่ 43b ตัวเลือก copyprivate ใน Fortran

2.3.5. คำสั่งหลัก

ตัวอย่าง 44a คำสั่งหลักในภาษา C
ตัวอย่าง 44ข คำสั่งหลักใน Fortran

2.4. แบบจำลองข้อมูล

ตัวอย่าง 45a ตัวเลือกส่วนตัวในภาษา C
ตัวอย่างที่ 45b ตัวเลือกส่วนตัวใน Fortran
ตัวอย่าง 46ก ตัวเลือกที่ใช้ร่วมกันในภาษา C
ตัวอย่าง 46ข ตัวเลือกที่ใช้ร่วมกันใน Fortran
ตัวอย่างที่ 47ก ตัวเลือกแรกส่วนตัวในภาษา C
ตัวอย่าง 47ข ตัวเลือกส่วนตัวอันดับหนึ่งใน Fortran
ตัวอย่าง 48a คำสั่ง threadprivate ในภาษา C
ตัวอย่าง 48ข คำสั่ง threadprivate ใน Fortran
ตัวอย่าง 49ก ตัวเลือก Copyin ในภาษา C
ตัวอย่าง 49ข ตัวเลือก copyin ใน Fortran

2.5. การกระจายงาน

2.5.1. การขนานระดับต่ำ

ตัวอย่าง 50a ขั้นตอน omp_get_num_threads และ omp_get_thread_num ในภาษา C
ตัวอย่าง 50ข ขั้นตอน omp_get_num_threads และ omp_get_thread_num ใน Fortran

2.5.2. ลูปขนาน

ตัวอย่างที่ 51a สำหรับคำสั่งในภาษา C
ตัวอย่างที่ 51ข คำสั่ง do ใน Fortran
ตัวอย่าง 52a ตัวเลือกกำหนดการในภาษา C
ตัวอย่าง 52b ตัวเลือกกำหนดการใน 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 โปรแกรมแบบขนานถูกกำหนดให้เป็นชุดของกระบวนการที่ดำเนินการพร้อมกัน กระบวนการต่างๆ สามารถดำเนินการได้บนโปรเซสเซอร์ที่แตกต่างกัน แต่กระบวนการต่างๆ ก็สามารถอยู่บนโปรเซสเซอร์เดียวกันได้ (ในกรณีนี้ กระบวนการต่างๆ จะถูกดำเนินการในโหมดการแบ่งเวลา) เมื่อรันโปรแกรม MPI บนคลัสเตอร์ แต่ละโหนดจะรันสำเนาของโปรแกรมของตัวเอง โดยทำหน้าที่ในส่วนของตัวเอง จากนั้นโปรแกรมแบบขนานคือชุดของกระบวนการโต้ตอบ ซึ่งแต่ละกระบวนการทำงานในตัวเอง พื้นที่ที่อยู่ ในกรณีที่รุนแรง สามารถใช้โปรเซสเซอร์ตัวเดียวเพื่อรันโปรแกรมแบบขนาน - ตามกฎแล้ว วิธีการนี้จะใช้เพื่อตรวจสอบความถูกต้องของโปรแกรมแบบขนานในขั้นต้น

จำนวนกระบวนการและจำนวนโปรเซสเซอร์ที่ใช้จะถูกกำหนด ณ เวลาที่เปิดตัวโปรแกรมแบบขนานโดยใช้สภาพแวดล้อมการดำเนินการโปรแกรม 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	ลงนามใน
MPI_ไม่ได้ลงนาม	int ที่ไม่ได้ลงนาม
MPI_SHORT	ลงนามใน
MPI_LONG	ลงนาม int ยาว
MPI_UNSIGNED_SHORT	int ที่ไม่ได้ลงนาม
MPI_UNSIGNED_LONG	int ยาวที่ไม่ได้ลงนาม
MPI_FLOAT	ลอย
MPI_สองเท่า	สองเท่า
MPI_LONG_สองเท่า	ยาวสองเท่า
MPI_UNSIGNED_CHAR	ถ่านที่ไม่ได้ลงนาม
MPI_CHAR	ถ่านที่ลงนาม

ตัวอย่างการเปิดตัวไลบรารี MPI: นักเรียนเข้าสู่ระบบ รหัสผ่าน s304

#รวม

int หลัก (int argc, ถ่าน *argv)

/* การเริ่มต้น MPI */

MPI_Init(&argc, &argv);

/* รับอันดับกระบวนการ */

MPI_Comm_rank (MPI_COMM_WORLD, &อันดับ);

/* รับจำนวนกระบวนการทั้งหมด */

MPI_Comm_size (MPI_COMM_WORLD, &ขนาด);

printf("สวัสดีชาวโลกจากกระบวนการ %d ของ %d\n", อันดับ, ขนาด);

/* MPI เสร็จสมบูรณ์ */

คอมไพเลอร์และลิงเกอร์ใช้สำหรับการคอมไพล์ บรรทัดคำสั่ง เอ็มพิค (ดู mpicc….- ความช่วยเหลือ)

แต่ละกระบวนการที่ทำงานอยู่ควรแสดงอันดับและจำนวนกระบวนการทั้งหมด มาลองคอมไพล์และรันโปรแกรมนี้กัน

$ mpicc hello.c –o สวัสดี o

$ mpicc สวัสดี.o –o สวัสดี

ไฟล์ hello จะเป็นไฟล์ปฏิบัติการตัวอย่าง คุณสามารถรันบนเครื่องเดียวและเห็นว่าจำนวนโปรเซสเซอร์จะเท่ากับ 1 และอันดับกระบวนการจะเป็น 0:

$./สวัสดี

สวัสดีชาวโลกจากกระบวนการ 0 จาก 1

เมื่อทำงานบนเซิร์ฟเวอร์ จะใช้คำสั่งเพื่อเริ่มต้น เอ็มไพรุน - มีสองอาร์กิวเมนต์หลัก - ชื่อของไฟล์ที่มีที่อยู่โหนดและจำนวนโหนดที่จะรันโปรแกรม

$ mpirun n0-6 –v โฮสต์สวัสดี

สวัสดีชาวโลกจากกระบวนการ 0 จาก 7

สวัสดีชาวโลกจากกระบวนการที่ 3 จาก 7

สวัสดีชาวโลกจากกระบวนการที่ 5 จาก 7

สวัสดีชาวโลกจากกระบวนการที่ 4 จาก 7

สวัสดีชาวโลกจากกระบวนการที่ 2 จาก 7

สวัสดีชาวโลกจากกระบวนการ 6 จาก 7

สวัสดีชาวโลกจากกระบวนการที่ 1 จาก 7

โปรแกรมจะทำงานบน 7 โหนด (รวมเซิร์ฟเวอร์) และที่อยู่ของโหนดเหล่านี้อยู่ใน ไฟล์โฮสต์การพิมพ์ลงบนหน้าจอดำเนินการโดยกระบวนการที่ไม่เรียงลำดับ เนื่องจากการทำงานของกระบวนการไม่ได้รับการซิงโครไนซ์ แต่ MPI มีฟังก์ชันพิเศษสำหรับการซิงโครไนซ์กระบวนการ

โปรแกรมที่ง่ายที่สุดไม่มีฟังก์ชั่นการถ่ายโอนข้อความ ในปัญหาที่แท้จริง กระบวนการต่างๆ จำเป็นต้องโต้ตอบซึ่งกันและกัน โดยปกติแล้วจะใช้เวลาในการส่งข้อความซึ่งจะช่วยลดค่าสัมประสิทธิ์การขนานของงาน ยิ่งความเร็วของอินเทอร์เฟซการถ่ายโอนข้อความสูงขึ้น (เช่น อีเธอร์เน็ต 10Mb/วินาที และ Gigabit Ethernet) ต้นทุนการถ่ายโอนข้อมูลก็จะยิ่งต่ำลง เพราะ เวลาในการแลกเปลี่ยนข้อมูลระหว่างกระบวนการนั้นนานกว่าเวลาในการเข้าถึงหน่วยความจำของตัวเองมาก (ตามลำดับความสำคัญ) การกระจายงานระหว่างกระบวนการควรเป็นแบบ 'หยาบ' และควรหลีกเลี่ยงการถ่ายโอนข้อมูลที่ไม่จำเป็น

ในบรรดาปัญหาของการวิเคราะห์เชิงตัวเลข มีปัญหาหลายอย่างที่เห็นความขนานชัดเจน ตัวอย่างเช่น การรวมเชิงตัวเลขจริงๆ แล้วขึ้นอยู่กับการคำนวณ (จำนวนมาก) ของฟังก์ชันปริพันธ์ (ซึ่งโดยธรรมชาติแล้วมอบหมายให้กับแต่ละกระบวนการ) ในขณะที่กระบวนการหลักควบคุมกระบวนการคำนวณ (กำหนดกลยุทธ์สำหรับการกระจายจุดการรวมระหว่างกระบวนการและรวบรวมผลรวมบางส่วน) . ปัญหาในการค้นหาและเรียงลำดับรายการเชิงเส้น การหารากของฟังก์ชันด้วยตัวเลข การค้นหาจุดสุดขีดของฟังก์ชันของตัวแปรหลายตัว การคำนวณอนุกรม และอื่นๆ ที่มีความคล้ายคลึงกัน ในแล็บนี้ เราจะดูอัลกอริทึมคู่ขนานสองตัวสำหรับการคำนวณ π

การคำนวณตัวเลข π โดยวิธีการรวมตัวเลข

เป็นที่ทราบกันว่า

เราได้แทนที่การคำนวณอินทิกรัลด้วยผลรวมอันจำกัดแล้ว โดยที่ n คือจำนวนส่วนการรวมระหว่างการรวมตัวเลข พื้นที่ของแต่ละส่วนคำนวณเป็นผลคูณของความกว้างของ 'แถบ' และค่าของฟังก์ชันที่อยู่ตรงกลางของ 'แถบ' จากนั้นพื้นที่จะถูกสรุปโดยกระบวนการหลัก (ตารางที่สม่ำเสมอคือ ใช้แล้ว).

แน่นอนว่าการทำให้ปัญหานี้ขนานกันนั้นทำได้ง่ายถ้าแต่ละกระบวนการคำนวณผลรวมบางส่วนแล้วส่งผลลัพธ์ของการคำนวณไปยังกระบวนการหลัก ฉันจะหลีกเลี่ยงการคำนวณซ้ำที่นี่ได้อย่างไร กระบวนการจะต้องทราบอันดับ จำนวนกระบวนการทั้งหมด และจำนวนช่วงเวลาที่เซกเมนต์จะถูกแบ่ง (ยิ่งช่วงเวลามากขึ้น ความแม่นยำก็จะยิ่งสูงขึ้น) จากนั้นในรอบตั้งแต่ 1 ถึงจำนวนช่วงเวลา กระบวนการจะคำนวณพื้นที่ของแถบบนช่วงเวลาที่ i-th จากนั้นจะไม่ย้ายไปยังช่วง i+1 ถัดไป แต่จะย้ายไปยังช่วง i+m โดยที่ m คือจำนวนกระบวนการ ดังที่เราทราบกันดีอยู่แล้วว่า มีฟังก์ชันสำหรับรับอันดับและจำนวนกระบวนการทั้งหมด MPI_Comm_rank และ MPI_Comm_size - ก่อนที่จะเริ่มการคำนวณ กระบวนการหลักจะต้องส่งจำนวนช่วงเวลาไปให้คนอื่นๆ และหลังจากการคำนวณ ให้รวบรวมผลรวมบางส่วนที่ได้รับจากพวกเขาและสรุปผลใน MPI ซึ่งจะดำเนินการโดยการส่งข้อความ สะดวกในการใช้ฟังก์ชันการโต้ตอบแบบรวมที่นี่เพื่อส่งข้อความ MPI_Bcast ซึ่งส่งข้อมูลเดียวกันจากกระบวนการหนึ่งไปยังกระบวนการอื่นทั้งหมด ในการรวบรวมจำนวนเงินบางส่วน มี 2 ตัวเลือก - คุณสามารถใช้ได้ MPI_รวบรวม ซึ่งรวบรวมข้อมูลจากกระบวนการทั้งหมดและมอบให้กับหนึ่งกระบวนการ (ได้รับอาร์เรย์ขององค์ประกอบ m โดยที่ m คือจำนวนกระบวนการ) หรือ MPI_ลด . MPI_ลด ทำหน้าที่คล้ายกัน MPI_รวบรวม – รวบรวมข้อมูลจากกระบวนการทั้งหมดและมอบให้กับกระบวนการหนึ่ง แต่ไม่ใช่ในรูปแบบของอาเรย์ แต่ก่อนอื่นให้ดำเนินการบางอย่างระหว่างองค์ประกอบของอาเรย์ เช่น การบวก จากนั้นให้องค์ประกอบหนึ่ง สำหรับงานนี้ดูเหมือนว่าจะสะดวกกว่าในการใช้งาน MPI_ลด - ข้อความของโปรแกรมได้รับด้านล่าง

#รวม "mpi.h"

#รวม

ดับเบิ้ลเอฟ(ดับเบิ้ลเอ)

กลับ (4.0 / (1.0 + a*a));

int หลัก (int argc, ถ่าน * argv)

int n, myid, numprocs, i;

PI25DT สองเท่า = 3.141592653589793238462643;

mypi สองเท่า, pi, h, ผลรวม, x;

เวลาเริ่มต้นสองเท่า, เวลาสิ้นสุด;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

เวลาเริ่มต้น = 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));

เวลาสิ้นสุด = 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_Wเวลาส่งคืนจำนวนวินาทีในรูปแบบจุดลอยตัวซึ่งแสดงถึงเวลาที่ผ่านไปนับตั้งแต่โปรแกรมเริ่มทำงาน

การคำนวณตัวเลข π โดยใช้วิธีมอนติคาร์โล

ในการคำนวณค่าของ π คุณสามารถใช้วิธี 'shooting' เมื่อนำไปใช้กับกรณีนี้ วิธีการจะประกอบด้วยการสร้างจุดที่มีการกระจายสม่ำเสมอในพื้นที่สองมิติ และการกำหนด

ค่า π ที่คำนวณในลักษณะนี้เป็นค่าโดยประมาณ โดยทั่วไป ความแม่นยำในการคำนวณค่าที่ต้องการจะเพิ่มขึ้นตามจำนวน 'ช็อต' และคุณภาพของตัวสร้างตัวเลขสุ่ม วิธีการที่คล้ายกันนี้ใช้เมื่อยากต่อการประมาณตัวเลขที่แม่นยำ

อัลกอริธึมแบบขนานสำหรับการคำนวณตัวเลข π โดยใช้วิธีนี้มีหลายวิธีคล้ายกับอัลกอริธึมก่อนหน้านี้ที่เราพิจารณา หากต้องการสร้างตัวเลขสุ่ม คุณต้องใช้ฟังก์ชัน srand ซึ่งกำหนดอันดับของกระบวนการเป็นอาร์กิวเมนต์ (sequence seed) เพื่อให้แต่ละกระบวนการมีลำดับของตัวเอง

#รวม

srand เป็นโมฆะ (เมล็ดที่ไม่ได้ลงนาม);

ฟังก์ชัน srand() กำหนดหมายเลขเมล็ดสำหรับลำดับที่สร้างโดยฟังก์ชัน rand()

#รวม

int rand (เป็นโมฆะ);

ฟังก์ชัน rand() สร้างลำดับของตัวเลขสุ่มเทียม แต่ละครั้งที่มีการเรียกใช้ฟังก์ชัน ระบบจะส่งกลับจำนวนเต็มระหว่างศูนย์ถึงค่า RAND_MAX

ในการรวบรวมผลลัพธ์ที่นี่ ยังสะดวกที่จะใช้ MPI_Reduce พร้อมการดำเนินการบวก (MPI_SUM) จากนั้นหารผลรวมผลลัพธ์ด้วยจำนวนโปรเซสเซอร์ เพื่อให้ได้ค่าเฉลี่ยเลขคณิต

int MPI_Reduce (โมฆะ* sendbuf, โมฆะ* recvbuf, จำนวน int,

ประเภทข้อมูล MPI_Datatype, MPI_Op op, int root, MPI_Comm comm);

ตัวเลือก:

ที่อยู่ sendbuf ของบัฟเฟอร์การส่ง

ที่อยู่ recvbuf ของบัฟเฟอร์ที่ได้รับ

การดำเนินการลดสหกรณ์

เครื่องมือสื่อสาร

int MPI_Bcast (โมฆะ * บัฟเฟอร์, จำนวน int, ประเภทข้อมูล MPI_Datatype, int root,

การสื่อสาร MPI_Comm);

ตัวเลือก:

ที่อยู่บัฟเฟอร์ของบัฟเฟอร์การส่ง/รับ

นับจำนวนองค์ประกอบในบัฟเฟอร์การส่ง (จำนวนเต็ม)

ประเภทข้อมูล ประเภทข้อมูลขององค์ประกอบบัฟเฟอร์การส่ง

หมายเลขกระบวนการหลักของรูท (จำนวนเต็ม)

เครื่องมือสื่อสาร

ออกกำลังกาย: ตามหมายเลขตัวเลือก ให้คอมไพล์และรันโปรแกรมคู่ขนานที่คำนวณตัวเลข π โดยใช้อัลกอริธึมที่กำหนด

รันงานบนโหนดเดียวและจากคลัสเตอร์ตามจำนวนโหนดที่ระบุ ประเมินเวลาในการคำนวณ ความแม่นยำ และสัมประสิทธิ์การขนานของ Amdahl โดยคำนึงถึงความล่าช้าของเครือข่ายตามทฤษฎีและตามผลลัพธ์ของงาน

ตัวเลือกงาน

ตัวเลือกหมายเลข	อัลกอริทึม	จำนวนโปรเซสเซอร์	จำนวนการวนซ้ำของโปรเซสเซอร์แต่ละตัว
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล
	การบูรณาการเชิงตัวเลข
	มอนติคาร์โล

· คำชี้แจงปัญหา ตัวเลือก

· ข้อความของโปรแกรมคู่ขนานในภาษา C ตามที่ได้รับมอบหมาย

· ผลลัพธ์ของการรันโปรแกรมบนโหนดเดียว เวลาดำเนินการ ผลการคำนวณ ข้อผิดพลาด

· ผลลัพธ์ของการรันโปรแกรมบนเซิร์ฟเวอร์ เวลาดำเนินการ ผลการคำนวณ ข้อผิดพลาด

· อธิบายอัลกอริธึมแบบขนาน การไหลของข้อมูลระหว่างการทำงานของโปรแกรม และการโหลดหน่วยความจำแคชของโหนด คำนวณค่าสัมประสิทธิ์ Amdahl - K j ตามผลลัพธ์ของโปรแกรม

· โดยคำนึงถึงผลงานของกลุ่มนักเรียน สร้างฮิสโตแกรมของการพึ่งพา K j ฉันเกี่ยวกับจำนวนโปรเซสเซอร์ที่เข้าร่วมในการคำนวณ

บทช่วยสอน

ในโพสต์นี้ เราจะพูดถึงการจัดการแลกเปลี่ยนข้อมูลโดยใช้ MPI โดยใช้ตัวอย่างของ Intel MPI Library เราคิดว่าข้อมูลนี้จะน่าสนใจสำหรับทุกคนที่ต้องการทำความคุ้นเคยกับสาขาการประมวลผลประสิทธิภาพสูงแบบขนานในทางปฏิบัติ

เราจะให้คำอธิบายโดยย่อเกี่ยวกับวิธีการจัดระเบียบการแลกเปลี่ยนข้อมูลในแอปพลิเคชันแบบคู่ขนานโดยยึดตาม MPI รวมถึงลิงก์ไปยังแหล่งข้อมูลภายนอกพร้อมคำอธิบายโดยละเอียดเพิ่มเติม ในภาคปฏิบัติ คุณจะพบคำอธิบายของทุกขั้นตอนของการพัฒนาแอปพลิเคชันสาธิต MPI “Hello World” โดยเริ่มจากการตั้งค่าสภาพแวดล้อมที่จำเป็นและสิ้นสุดด้วยการเปิดตัวโปรแกรม

MPI (อินเทอร์เฟซการส่งข้อความ)

MPI เป็นอินเทอร์เฟซการส่งข้อความระหว่างกระบวนการที่ปฏิบัติงานเดียวกัน มีจุดประสงค์เพื่อระบบหน่วยความจำแบบกระจาย (MPP) เป็นหลัก ซึ่งตรงข้ามกับ OpenMP เช่น ตามกฎแล้ว ระบบแบบกระจาย (คลัสเตอร์) คือชุดของโหนดการคำนวณที่เชื่อมต่อกันด้วยช่องทางการสื่อสารประสิทธิภาพสูง (เช่น InfiniBand)

MPI เป็นมาตรฐานอินเทอร์เฟซข้อมูลทั่วไปสำหรับการเขียนโปรแกรมแบบขนาน การกำหนดมาตรฐาน MPI ดำเนินการโดย MPI Forum มีการใช้งาน MPI สำหรับแพลตฟอร์ม ระบบปฏิบัติการ และภาษาที่ทันสมัยที่สุด MPI ถูกนำมาใช้กันอย่างแพร่หลายในการแก้ปัญหาต่างๆ ในฟิสิกส์การคำนวณ เภสัชกรรม วัสดุศาสตร์ พันธุศาสตร์ และความรู้สาขาอื่นๆ

จากมุมมองของ MPI โปรแกรมแบบขนานคือชุดของกระบวนการที่ทำงานบนโหนดการประมวลผลที่แตกต่างกัน แต่ละกระบวนการเกิดจากรหัสโปรแกรมเดียวกัน

การดำเนินการหลักใน MPI คือการส่งข้อความ MPI ใช้รูปแบบการสื่อสารพื้นฐานเกือบทั้งหมด: แบบจุดต่อจุด แบบรวมกลุ่ม และแบบด้านเดียว

ร่วมงานกับ MPI

มาดูตัวอย่างสดของโครงสร้างโปรแกรม MPI ทั่วไปกัน ในฐานะแอปพลิเคชันสาธิต เรามาลองใช้ซอร์สโค้ดตัวอย่างที่มาพร้อมกับ Intel MPI Library ก่อนที่จะรันโปรแกรม MPI แรกของเรา เราต้องเตรียมและตั้งค่าสภาพแวดล้อมการทำงานสำหรับการทดลอง

การตั้งค่าสภาพแวดล้อมคลัสเตอร์

สำหรับการทดลอง เราจะต้องมีโหนดการคำนวณหนึ่งคู่ (โดยเฉพาะอย่างยิ่งที่มีลักษณะคล้ายกัน) หากคุณไม่มีเซิร์ฟเวอร์สองเครื่อง คุณสามารถใช้บริการคลาวด์ได้ตลอดเวลา

สำหรับการสาธิต ฉันเลือกบริการ Amazon Elastic Compute Cloud (Amazon EC2) Amazon มอบสิทธิ์ทดลองใช้เซิร์ฟเวอร์ระดับเริ่มต้นแก่ผู้ใช้ใหม่ฟรีเป็นเวลาหนึ่งปี

การทำงานกับ Amazon EC2 เป็นเรื่องง่าย หากคุณมีคำถามใด ๆ คุณสามารถดูเอกสารโดยละเอียดได้ (เป็นภาษาอังกฤษ) หากต้องการคุณสามารถใช้บริการอื่นที่คล้ายคลึงกันได้

เราสร้างเซิร์ฟเวอร์เสมือนที่ใช้งานได้สองเครื่อง ในคอนโซลการจัดการให้เลือก เซิร์ฟเวอร์เสมือน EC2 ในระบบคลาวด์, แล้ว เปิดตัวอินสแตนซ์("อินสแตนซ์" หมายถึงอินสแตนซ์เซิร์ฟเวอร์เสมือน)

ขั้นตอนต่อไปคือการเลือกระบบปฏิบัติการ ไลบรารี Intel MPI รองรับทั้ง Linux และ Windows สำหรับการทำความรู้จักกับ MPI ครั้งแรกเราจะเลือก OS Linux เลือก Red Hat Enterprise Linux 6.6 64 บิตหรือ SLES11.3/12.0.
เลือก ประเภทอินสแตนซ์(ประเภทเซิร์ฟเวอร์) สำหรับการทดลอง t2.micro (1 vCPU, 2.5 GHz, ตระกูลโปรเซสเซอร์ Intel Xeon, RAM 1 GiB) เหมาะสำหรับเรา ในฐานะผู้ใช้ที่ลงทะเบียนเมื่อเร็วๆ นี้ ฉันสามารถใช้ประเภทนี้ได้ฟรี โดยทำเครื่องหมายว่า "มีสิทธิ์ระดับฟรี" เราตั้ง จำนวนอินสแตนซ์: 2 (จำนวนเซิร์ฟเวอร์เสมือน)

หลังจากที่บริการแจ้งให้เราเรียกใช้ เปิดตัวอินสแตนซ์(เซิร์ฟเวอร์เสมือนที่กำหนดค่า) เราจะบันทึกคีย์ SSH ที่จำเป็นในการสื่อสารกับเซิร์ฟเวอร์เสมือนจากภายนอก สามารถตรวจสอบสถานะของเซิร์ฟเวอร์เสมือนและที่อยู่ IP สำหรับการสื่อสารกับเซิร์ฟเวอร์คอมพิวเตอร์ในระบบได้ในคอนโซลการจัดการ

จุดสำคัญ: ในการตั้งค่า เครือข่ายและความปลอดภัย / กลุ่มความปลอดภัยเราจำเป็นต้องสร้างกฎที่จะเปิดพอร์ตสำหรับการเชื่อมต่อ TCP ซึ่งจำเป็นสำหรับผู้จัดการกระบวนการ MPI กฎอาจมีลักษณะดังนี้: