mpy.mpich2 - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

mpy - ข้อความผ่าน Yorick

เรื่องย่อ

mpirun -np mp_size เอ็มปี้ [ -NS pfile1.i [ -NS pfile2.i [ ... ]]] [ -ผม ไฟล์ 1.i [ -ผม ไฟล์ 2.i [
-
mpirun -np mp_size เอ็มปี้ -แบทช์ ไฟล์.i

DESCRIPTION

ยอริค เป็นภาษาที่แปลเช่น Basic หรือ Lisp แต่เร็วกว่ามาก ดู โยริก (1) ถึง
เรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้
พาย เป็นรุ่นคู่ขนานของ ยอริค ขึ้นอยู่กับส่วนต่อประสานการส่งข้อความ (MPI) NS
ไวยากรณ์ที่แน่นอนสำหรับการเรียกใช้งานแบบขนานนั้นขึ้นอยู่กับสภาพแวดล้อม MPI ของคุณ มันอาจจะ
จำเป็นต้องเปิดภูตพิเศษก่อนเรียก มิรุณ หรือคำสั่งเทียบเท่า

คำอธิบาย
แพ็คเกจ mpy เชื่อมต่อ yorick กับไลบรารีโปรแกรมมิงแบบขนาน MPI MPI ย่อมาจาก
อินเทอร์เฟซการส่งข้อความ แนวคิดคือการเชื่อมโยง yorick หลาย ๆ ตัวอย่างที่
สื่อสารกันเองผ่านข้อความ Mpy สามารถดำเนินการอย่างง่าย ๆ ขนานสูง
งานเป็นโปรแกรมแปลบริสุทธิ์หรือสามารถเริ่มต้นและคัดท้ายคอมไพล์ที่ซับซ้อนโดยพลการ
แพ็คเกจที่สามารถใช้ MPI API ที่คอมไพล์ได้ฟรี API ที่ตีความไม่ได้มีวัตถุประสงค์
เป็นเครื่องห่อ MPI; แทนที่จะถูกปล้นให้เหลือน้อยที่สุด

นี่คือเวอร์ชัน 2 ของ mpy (เผยแพร่ในปี 2010); มันเข้ากันไม่ได้กับรุ่น 1 ของ mpy
(เปิดตัวเมื่อกลางปี ​​1990) เนื่องจากเวอร์ชัน 1 มีข้อบกพร่องด้านการออกแบบมากมายทำให้ดูดีมาก
เขียนโปรแกรมยากโดยไม่มีเงื่อนไขการแข่งขัน และไม่สามารถขยายเป็นล้านได้
ของโปรเซสเซอร์ อย่างไรก็ตาม คุณสามารถเรียกใช้โปรแกรม mpy เวอร์ชัน 1 ส่วนใหญ่ภายใต้เวอร์ชัน 2 ได้โดยทำ
mp_include,"mpy1.i" ก่อนที่คุณจะ mp_include ไฟล์ใด ๆ ที่กำหนดงานขนาน mpy1 (นั่นคือ
ก่อนที่ไฟล์ใด ๆ จะมีการเรียก mp_task)

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

ปัญหาสำคัญในการเขียนโปรแกรมส่งข้อความคือการจัดการเหตุการณ์หรือข้อความ
มาถึงโดยไม่ได้ตั้งใจ MPI รับประกันเฉพาะว่าลำดับของข้อความที่ส่งโดย
ระดับ A ถึงอันดับ B จะมาถึงตามลำดับที่ส่ง ไม่มีการรับประกันเกี่ยวกับคำสั่งของ
การมาถึงของข้อความที่สัมพันธ์กับข้อความที่ส่งถึง B จากอันดับที่สาม C. In
โดยเฉพาะอย่างยิ่ง สมมติว่า A ส่งข้อความถึง B จากนั้น A ส่งข้อความถึง C (หรือแม้แต่การแลกเปลี่ยน
หลายข้อความด้วย C) ซึ่งส่งผลให้ C ส่งข้อความถึง B ข้อความจากC
อาจมาถึง B ก่อนข้อความจาก A. โปรแกรม MPI ที่ไม่อนุญาตสำหรับสิ่งนี้
ความเป็นไปได้มีข้อผิดพลาดที่เรียกว่า "สภาพการแข่งขัน" สภาพการแข่งขันอาจบอบบางมาก
โดยเฉพาะอย่างยิ่งเมื่อมีกระบวนการจำนวนมาก

อินเทอร์เฟซที่ตีความ mpy พื้นฐานประกอบด้วยสองตัวแปร:
mp_size = จำนวนกระบวนการ
mp_rank = อันดับของกระบวนการนี้และสี่หน้าที่:
mp_send ไปที่ msg; // ส่งข้อความถึงอันดับ "ถึง"
msg = mp_recv(จาก); // รับข้อความจากอันดับ "จาก"
อันดับ = mp_probe(บล็อก); // สอบถามผู้ส่งข้อความที่รอดำเนินการ
mp_exec, สตริง; // แยกวิเคราะห์และรันสตริงในทุกอันดับ

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

แพ็คเกจ mpy ปรับเปลี่ยนวิธีที่ yorick จัดการกับ #include parser directive และ include
และต้องการฟังก์ชัน กล่าวคือ ถ้างานคู่ขนานกำลังทำงานอยู่ (นั่นคือ ฟังก์ชันเริ่มทำงาน
โดย mp_exec) ทั้งหมดนี้กลายเป็นปฏิบัติการร่วมกัน นั่นคืออันดับ 0 อ่านทั้งหมด
เนื้อหาไฟล์ และส่งเนื้อหาไปยังกระบวนการอื่นเป็นข้อความ MPI (เช่น
mp_exec ของเนื้อหาไฟล์) ทุกกระบวนการนอกเหนือจากอันดับ 0 จะทำงานเฉพาะระหว่าง
งานคู่ขนาน นอกงานคู่ขนานเมื่อทำงานเฉพาะอันดับ 0 (และอันดับอื่น ๆ ทั้งหมด
กำลังรอ mp_exec ถัดไป) #include directive และ include และ require
ฟังก์ชันจะกลับสู่การทำงานแบบอนุกรมตามปกติ โดยมีผลกับอันดับ 0 เท่านั้น

เมื่อ mpy เริ่มทำงาน มันจะอยู่ในโหมดขนาน ดังนั้นไฟล์ทั้งหมดที่ yorick จะรวมไว้เมื่อไฟล์นั้น
เริ่มต้น (ไฟล์ใน Y_SITE/i0) ถูกรวมเป็นการดำเนินการแบบรวม ไม่มีสิ่งนี้
ทุกกระบวนการ yorick จะพยายามเปิดและอ่านการเริ่มต้นรวมถึงไฟล์
โอเวอร์โหลดระบบไฟล์ก่อนที่ mpy จะเริ่มต้นขึ้น ผ่านเนื้อหาเหล่านี้
ไฟล์ที่เป็นข้อความ MPI เป็นวิธีเดียวที่จะทำให้แน่ใจว่ามีแบนด์วิดธ์เพียงพอสำหรับทุกๆ
กระบวนการอ่านเนื้อหาของไฟล์เดียว

ไฟล์สุดท้ายที่รวมไว้เมื่อเริ่มต้นคือไฟล์ที่ระบุในตัวเลือก -batch หรือ
ไฟล์ custom.i เพื่อหลีกเลี่ยงปัญหากับโค้ดใน custom.i ซึ่งอาจไม่ปลอดภัยสำหรับ
การดำเนินการแบบขนาน mpy ไม่ได้มองหา custom.i แต่สำหรับ custommp.i แทน NS
คำแนะนำในไฟล์ -batch หรือใน custommp.i ถูกดำเนินการในโหมดซีเรียลที่อันดับ 0
เท่านั้น. ในทำนองเดียวกัน mpy จะแทนที่ฟังก์ชัน process_argv ปกติ ดังนั้น -i และ other
ตัวเลือกบรรทัดคำสั่งจะได้รับการประมวลผลเฉพาะที่อันดับ 0 ในโหมดซีเรียล เจตนาในสิ่งเหล่านี้
กรณีคือการทำให้ -batch หรือ custommp.i หรือ -i รวมไฟล์ที่รันเฉพาะที่อันดับ 0 เช่น
ถ้าคุณได้พิมพ์พวกเขาที่นั่นแบบโต้ตอบ คุณมีอิสระที่จะโทรหา mp_exec จากสิ่งเหล่านี้
ไฟล์เพื่อเริ่มงานแบบขนาน แต่ตัวไฟล์นั้นเป็นแบบอนุกรม

เพิ่มตัวเลือกบรรทัดคำสั่งเพิ่มเติมในชุดปกติ:
mpy -j somefile.i
รวม somefile.i ในโหมดคู่ขนานในทุกอันดับ (อีกครั้ง -i other.i รวม other.i เท่านั้น
ที่อันดับ 0 ในโหมดซีเรียล) หากมีตัวเลือก -j หลายตัว ค่าขนานจะรวมไว้ด้วย
ในลำดับบรรทัดคำสั่ง หากตัวเลือก -j และ -i ผสมกัน อย่างไรก็ตาม -j ทั้งหมดจะรวมไว้ด้วย
ก่อน -i ใด ๆ รวมถึง

เนื่องจากผลข้างเคียงของความซับซ้อนของฟังก์ชัน include ใน mpy คุณสมบัติการโหลดอัตโนมัติคือ
พิการ; หากโค้ดของคุณทริกเกอร์การรวมโดยเรียกใช้ฟังก์ชันที่โหลดอัตโนมัติ mpy
จะหยุดโดยมีข้อผิดพลาด คุณต้องโหลดฟังก์ชันใด ๆ ที่จำเป็นสำหรับ Parallel . อย่างชัดเจน
งานที่ใช้ฟังก์ชัน require เรียกตัวเองว่าภายในงานคู่ขนาน

ฟังก์ชัน mp_send สามารถส่งอาร์เรย์ yorick ที่เป็นตัวเลขใดๆ (ประเภท char, short, int, long,
float, double หรือ complex) หรือค่าสตริงสเกลาร์ ขั้นตอนการส่งข้อความ
ผ่าน MPI จะรักษาจำนวนองค์ประกอบเท่านั้น ดังนั้น mp_recv จึงสร้างเฉพาะค่าสเกลาร์หรือ
อาร์เรย์ของค่า 1D ไม่ว่ามิติใดจะถูกส่งไปยัง mp_send

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

ฟังก์ชัน mp_probe ส่งคืนรายชื่อผู้ส่งข้อความที่อยู่ในคิวทั้งหมด (หรือไม่มี if
คิวว่าง) เรียก mp_probe(0) เพื่อกลับทันที แม้ว่าคิวจะว่าง
โทร mp_probe(1) บล็อกถ้าคิวว่าง ส่งคืนเฉพาะเมื่อมีข้อความอย่างน้อยหนึ่งข้อความ
สามารถใช้ได้กับ mp_recv เรียก mp_probe(2) เพื่อบล็อกจนกว่าจะมีข้อความใหม่มาถึงแม้ว่า
มีข้อความบางข้อความอยู่ในขณะนี้

ฟังก์ชัน mp_exec ใช้ fanout ลอการิทึม - อันดับ 0 ส่งไปยังโปรเซส F แต่ละตัวของ
ซึ่งส่งไปยัง F มากขึ้นเรื่อย ๆ จนกว่ากระบวนการทั้งหมดจะมีข้อความ เมื่อกระบวนการ
เสร็จสิ้นการดำเนินการส่งทั้งหมด แยกวิเคราะห์และดำเนินการเนื้อหาของข้อความ
อัลกอริธึม fanout ไปถึง N โปรเซสในบันทึกไปยังฐาน F ของ N ขั้นตอน กระบวนการ F
อันดับ 0 ที่ส่งไปคืออันดับ 1, 2, 3, ..., F. โดยทั่วไป กระบวนการที่มีอันดับ r จะส่งไปที่
r*F+1, r*F+2, ..., r*F+F (เมื่อสิ่งเหล่านี้น้อยกว่า N-1 สำหรับกระบวนการ N) ชุดนี้
เรียกว่า “พนักงาน” ยศ r. อันดับที่มี r>0 ได้รับข้อความจากอันดับ (r-1)/F
ซึ่งเรียกว่า "เจ้านาย" ของอาร์ การเรียก mp_exec ทำงานร่วมกับคิว mp_recv
กล่าวอีกนัยหนึ่งข้อความจากอันดับอื่นที่ไม่ใช่เจ้านายระหว่าง fanout mp_exec จะเป็น
เข้าคิวเพื่อเรียกค้นในภายหลังโดย mp_recv (หากไม่มีคุณลักษณะนี้ งานคู่ขนานใดๆ ที่
ใช้รูปแบบข้อความอื่นที่ไม่ใช่ลอการิทึม fanout จะไวต่อการแข่งขัน
เงื่อนไข.)

ลอการิทึม fanout และค่าเทียบเท่าภายในนั้นมีประโยชน์มากที่ mpy จัดเตรียมคู่
ของฟังก์ชันระดับสูงกว่าที่ใช้รูปแบบ fanout เดียวกันกับ mp_exec:
mp_handout, ผงชูรส;
รวม = mp_handin(ค่า);
ในการใช้ mp_handout อันดับ 0 จะคำนวณข้อความ จากนั้นทุกอันดับจะเรียก mp_handout ซึ่งจะส่ง msg
(เอาต์พุตในทุกอันดับอื่นที่ไม่ใช่ 0) ทุกที่โดย fanout เดียวกันกับ mp_exec ใช้
mp_handin ทุกกระบวนการคำนวณค่า จากนั้นเรียก mp_handin ซึ่งจะคืนค่าผลรวมของ
คุณค่าของตัวเองและพนักงานทั้งหมดของพวกเขา ดังนั้นในอันดับ 0 mp_handin จะส่งกลับผลรวมของ
คุณค่าจากทุกกระบวนการ

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

คุณสามารถดึงหรือเปลี่ยนพารามิเตอร์ fanout F ได้โดยใช้ฟังก์ชัน mp_nfan ค่าเริ่มต้น
ค่าคือ 16 ซึ่งควรจะสมเหตุสมผลแม้ในกระบวนการจำนวนมาก

งานคู่ขนานพิเศษหนึ่งงานเรียกว่า mp_connect ซึ่งคุณสามารถใช้เพื่อป้อนการตีความ
บรรทัดคำสั่งไปยังอันดับใด ๆ ที่ไม่ใช่ 0 ในขณะที่อันดับอื่น ๆ ทั้งหมดไม่ได้ใช้งาน อันดับ 0 อยู่ใน a
วนรอบการอ่านแป้นพิมพ์และส่งบรรทัดไปยังอันดับ "เชื่อมต่อ" ซึ่งดำเนินการ
และส่งการตอบรับกลับไปที่อันดับ 0 คุณเรียกใช้ฟังก์ชัน mp_disconnect ไปที่
ทำงานแบบคู่ขนานให้เสร็จและเลื่อนกลับไปที่อันดับ 0

สุดท้าย บันทึกเกี่ยวกับการกู้คืนข้อผิดพลาด ในกรณีที่เกิดข้อผิดพลาดระหว่างงานคู่ขนาน
mpy พยายามออกจาก mp_exec อย่างสง่างาม ดังนั้นเมื่ออันดับ 0 กลับมา อันดับอื่นทั้งหมด
เป็นที่ทราบกันว่าไม่ได้ใช้งาน พร้อมสำหรับ mp_exec ถัดไป ขั้นตอนนี้จะหยุดถาวรถ้ามี
กระบวนการใดกระบวนการหนึ่งอยู่ในวงวนไม่สิ้นสุด หรืออยู่ในสถานะที่จะไม่เกิดขึ้นเลย
โทร mp_send, mp_recv หรือ mp_probe เนื่องจาก MPI ไม่มีวิธีการส่งสัญญาณที่
ขัดจังหวะกระบวนการทั้งหมด (นี่เป็นหนึ่งในวิธีที่สภาพแวดล้อม MPI เป็น
"หยาบ".) กระบวนการอันดับ 0 เหลืออันดับของกระบวนการแรกที่รายงาน a
ข้อบกพร่อง บวกกับจำนวนกระบวนการที่ผิดพลาดด้วยเหตุผลอื่นที่ไม่ใช่
ส่งข้อความว่ายศอื่นมีความผิด กระบวนการที่ผิดพลาดครั้งแรกสามารถเข้าสู่ dbug
โหมดผ่าน mp_connect; ใช้ mp_disconnect หรือ dbexit เพื่อย้อนกลับไปยังโหมดซีเรียลที่อันดับ 0

Options
-j ไฟล์.i รวมไฟล์ต้นฉบับ Yorick ไฟล์.i เมื่อ mpy เริ่มในโหมดคู่ขนาน
ในทุกอันดับ ซึ่งเทียบเท่ากับฟังก์ชัน mp_include หลัง mpy
ได้เริ่มต้นขึ้น

-i ไฟล์.i รวมไฟล์ต้นฉบับ Yorick ไฟล์.i เมื่อ mpy เริ่มทำงาน ในโหมดซีเรียล
ซึ่งเทียบเท่ากับคำสั่ง #include หลังจากที่ mpy เริ่มทำงาน

-แบทช์ ไฟล์.i รวมไฟล์ต้นฉบับ Yorick ไฟล์.i เมื่อ mpy เริ่มทำงาน ในโหมดซีเรียล
ไฟล์ปรับแต่งของคุณ custommp.i หากมี คือ ไม่ อ่านแล้ว mpy คือ
วางในโหมดแบทช์ ใช้คำสั่งช่วยเหลือในฟังก์ชันแบตช์
(ช่วยเหลือ, แบทช์) เพื่อค้นหาเพิ่มเติมเกี่ยวกับโหมดแบทช์ ในโหมดแบตช์ ทั้งหมด
ข้อผิดพลาดร้ายแรง ปกติ mpy จะหยุดดำเนินการและรอเพิ่มเติม
อินพุตหลังจากเกิดข้อผิดพลาด

ใช้ mpy.mpich2 ออนไลน์โดยใช้บริการ onworks.net