pegasus-mpi-cluster - ออนไลน์ใน Cloud

โครงการ:

ชื่อ

pegasus-mpi-cluster - เครื่องมือสำหรับการรันเวิร์กโฟลว์การคำนวณที่แสดงเป็น DAG
(Directed Acyclic Graphs) บนคลัสเตอร์คอมพิวเตอร์โดยใช้ MPI

เรื่องย่อ

เพกาซัส-mpi-คลัสเตอร์ [ตัวเลือก] เวิร์กโฟลว์.dag

DESCRIPTION

เพกาซัส-mpi-คลัสเตอร์ เป็นเครื่องมือที่ใช้ในการรัน HTC (High Throughput Computing) ทางวิทยาศาสตร์
เวิร์กโฟลว์บนระบบที่ออกแบบมาสำหรับ HPC (คอมพิวเตอร์ประสิทธิภาพสูง) ระบบ HPC จำนวนมากมี
สถาปัตยกรรมแบบกำหนดเองที่ได้รับการปรับให้เหมาะสมสำหรับแอปพลิเคชันคู่ขนานที่เชื่อมต่อกันอย่างแน่นหนา เหล่านี้
ระบบมักมีเครือข่ายที่แปลกใหม่และมีความหน่วงต่ำซึ่งออกแบบมาเพื่อการส่งผ่านระยะสั้น
ข้อความระหว่างโหนดคอมพิวท์อย่างรวดเร็ว หลายเครือข่ายเหล่านี้สูงมาก
ปรับให้เหมาะสมที่โหนดคอมพิวท์ไม่สนับสนุนสแต็ก TCP/IP ด้วยซ้ำ นี้ทำให้
ไม่สามารถเรียกใช้แอปพลิเคชัน HTC โดยใช้ซอฟต์แวร์ที่ออกแบบมาสำหรับสินค้าโภคภัณฑ์
กระจุก เช่น Condor

เพกาซัส-mpi-คลัสเตอร์ ได้รับการพัฒนาเพื่อเปิดใช้งานแอพพลิเคชั่น HTC ที่เชื่อมต่อกันอย่างหลวม ๆ เช่น
เวิร์กโฟลว์ทางวิทยาศาสตร์เพื่อใช้ประโยชน์จากระบบ HPC เพื่อการเดินทางรอบเครือข่าย
ประเด็นที่กล่าวข้างต้น เพกาซัส-mpi-คลัสเตอร์ ใช้ MPI (Message Passing Interface), a
API ที่ใช้กันทั่วไปในการเขียนแอปพลิเคชันแบบขนาน SPMD (กระบวนการเดียว หลายข้อมูล)
ระบบ HPC ส่วนใหญ่มีการนำ MPI มาใช้ซึ่งทำงานบนเครือข่ายที่แปลกใหม่
สถาปัตยกรรมที่ระบบใช้

An เพกาซัส-mpi-คลัสเตอร์ งานประกอบด้วยกระบวนการหลักเดียว (กระบวนการนี้คืออันดับ 0 ใน
สำนวน MPI) และกระบวนการทำงานหลายอย่าง กระบวนการหลักจัดการเวิร์กโฟลว์และ
มอบหมายงานเวิร์กโฟลว์ให้กับผู้ปฏิบัติงานเพื่อดำเนินการ คนงานดำเนินการงานและส่งคืน
ผลลัพธ์สู่เจ้านาย เอาต์พุตใดๆ ที่เขียนไปยัง stdout หรือ stderr โดยงานจะถูกบันทึก
(ดู งาน STDIUM).

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

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

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

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

OPTIONS

-h, --ช่วยด้วย
พิมพ์ข้อความช่วยเหลือ

-V, --รุ่น
พิมพ์ข้อมูลรุ่น

-v, --รายละเอียด
เพิ่มความฟุ่มเฟือยการบันทึก การเพิ่มทวีคูณ -v เพิ่มระดับมากขึ้น ค่าเริ่มต้น
ระดับล็อกคือ ข้อมูล. (ดู เข้าสู่ระบบ)

-q, --เงียบ
ลดการใช้คำฟุ่มเฟือยการบันทึก การเพิ่มทวีคูณ -q ลดระดับมากขึ้น ค่าเริ่มต้น
ระดับล็อกคือ ข้อมูล. (ดู เข้าสู่ระบบ)

-s, --ข้าม-กู้ภัย
ละเว้นไฟล์กู้ภัยสำหรับ เวิร์กโฟลว์.dag ถ้ามันมีอยู่ สังเกตว่า เพกาซัส-mpi-คลัสเตอร์
จะยังคงสร้างไฟล์กู้ภัยใหม่สำหรับการเรียกใช้ปัจจุบัน พฤติกรรมเริ่มต้นคือto
ใช้ไฟล์กู้ภัยหากพบ (ดู กู้ภัย ไฟล์)

-o เส้นทาง, --stdout เส้นทาง
เส้นทางไปยังไฟล์สำหรับงาน stdout (ดู งาน STDIUM และ --ต่องาน-stdio)

-e เส้นทาง, --สแตเดอร์ เส้นทาง
พาธไปยังไฟล์สำหรับงาน stderr (ดู งาน STDIUM และ --ต่องาน-stdio)

-m M, --max-ความล้มเหลว M
หยุดส่งงานใหม่หลังจาก M งานล้มเหลว ครั้งหนึ่ง M ถึงแล้ว
เพกาซัส-mpi-คลัสเตอร์ จะเสร็จสิ้นการทำงานใดๆ ที่เริ่มต้นไปแล้ว แต่จะไม่
เริ่มงานใด ๆ เพิ่มเติม ตัวเลือกนี้ใช้เพื่อป้องกัน เพกาซัส-mpi-คลัสเตอร์ จาก
ดำเนินการต่อเพื่อเรียกใช้เวิร์กโฟลว์ที่ได้รับผลกระทบจากข้อผิดพลาดอย่างเป็นระบบ เช่น a
ไม่มีไบนารีหรือเส้นทางที่ไม่ถูกต้อง ค่าเริ่มต้นสำหรับ M คือ 0 ซึ่งหมายถึงไม่จำกัด
อนุญาตให้มีความล้มเหลว

-t T, --พยายาม T
พยายามเรียกใช้แต่ละงาน T ครั้งก่อนที่จะทำเครื่องหมายงานว่าล้มเหลว โปรดทราบว่า T
ความพยายามไม่นับเป็นความล้มเหลวตามวัตถุประสงค์ของ -m ตัวเลือก. งานเท่านั้น
ถือว่าล้มเหลวหากพยายาม T ครั้งและทั้งหมด T ความพยายามส่งผลให้ไม่เป็นศูนย์
รหัสทางออก คุณค่าของ T ต้องมีอย่างน้อย 1 ค่าเริ่มต้นคือ 1

-n, --โนล็อค
อย่าล็อค DAGFILE โดยค่าเริ่มต้น, เพกาซัส-mpi-คลัสเตอร์ จะพยายามได้มาซึ่ง
ล็อค DAGFILE แบบเอกสิทธิ์เฉพาะบุคคลเพื่อป้องกันไม่ให้งาน MPI หลายงานเรียกใช้ DAG เดียวกันที่
ในเวลาเดียวกัน หากระบุตัวเลือกนี้ จะไม่มีการล็อก

-r, --กู้ภัย เส้นทาง
เส้นทางสู่บันทึกกู้ภัย หากไฟล์นั้นมีอยู่และ -s ไม่ได้ระบุบันทึกจะเป็น
ใช้ในการกู้คืนสถานะของเวิร์กโฟลว์ ไฟล์จะถูกตัดทอนหลังจากอ่านแล้ว
บันทึกการช่วยเหลือใหม่จะถูกสร้างขึ้นแทน ค่าเริ่มต้นคือการผนวก .กู้ภัย สู่ DAG
ชื่อไฟล์. (ดู กู้ภัย ไฟล์)

--host-สคริปต์ เส้นทาง
เส้นทางไปยังสคริปต์หรือไฟล์เรียกทำงานเพื่อเปิดในแต่ละโฮสต์ที่ไม่ซ้ำกันซึ่ง เพกาซัส-mpi-คลัสเตอร์
กำลังดำเนินการอยู่ เส้นทางนี้ยังสามารถตั้งค่าได้โดยใช้สภาพแวดล้อม PMC_HOST_SCRIPT
ตัวแปร. (ดู HOST สคริปต์)

--โฮสต์หน่วยความจำ ขนาด
จำนวนหน่วยความจำที่มีอยู่ในแต่ละโฮสต์ในหน่วย MB ค่าเริ่มต้นคือการกำหนดจำนวนเงิน
ของ RAM จริงโดยอัตโนมัติ ค่านี้ยังสามารถตั้งค่าได้โดยใช้ PMC_HOST_MEMORY
ตัวแปรสภาพแวดล้อม (ดู อิงจากทรัพยากร กำหนดการ)

--โฮสต์ซีพียู ซีพียู
จำนวน CPU ที่มีอยู่ในแต่ละโฮสต์ ค่าเริ่มต้นคือการกำหนดจำนวน CPU
แกนโดยอัตโนมัติ ค่านี้ยังสามารถตั้งค่าได้โดยใช้สภาพแวดล้อม PMC_HOST_CPUS
ตัวแปร. (ดู อิงจากทรัพยากร กำหนดการ)

--ข้อจำกัดที่เข้มงวด
ซึ่งช่วยให้มีขีดจำกัดการใช้หน่วยความจำอย่างเข้มงวดสำหรับงาน เมื่อระบุตัวเลือกนี้และ
งานพยายามจัดสรรหน่วยความจำมากกว่าที่ร้องขอใน DAG หน่วยความจำ
การดำเนินการจัดสรรจะล้มเหลว

--max-wall-time นาที
นี่คือจำนวนนาทีสูงสุดที่ เพกาซัส-mpi-คลัสเตอร์ จะช่วยให้เวิร์กโฟลว์
วิ่ง. เมื่อหมดเวลานี้ เพกาซัส-mpi-คลัสเตอร์ จะยกเลิกเวิร์กโฟลว์และผสาน
ไฟล์ stdout/stderr ทั้งหมดของผู้ปฏิบัติงาน ค่าเป็นนาที และ
ค่าเริ่มต้นคือไม่จำกัดเวลา เพิ่มตัวเลือกนี้เพื่อให้ผลลัพธ์ของเวิร์กโฟลว์
จะถูกบันทึกแม้ว่าเวิร์กโฟลว์จะเกินเวลาทำงานสูงสุดของชุดงาน นี้
ค่ายังสามารถตั้งค่าได้โดยใช้ตัวแปรสภาพแวดล้อม PMC_MAX_WALL_TIME

--ต่องาน-stdio
ซึ่งทำให้ PMC สร้างไฟล์ .out.XXX และ .err.XXX สำหรับแต่ละงานแทน
เขียนงาน stdout/stderr ถึง --stdout และ --สแตเดอร์. ชื่อของไฟล์คือ
"TASKNAME.out.XXX" และ "TASKNAME.err.XXX" โดยที่ "TASKNAME" เป็นชื่อของงาน
จาก DAG และ "XXX" คือหมายเลขลำดับที่เพิ่มขึ้นทุกครั้งที่มีงาน
พยายาม. ตัวเลือกนี้จะแทนที่ค่าสำหรับ --stdout และ --สแตเดอร์. อาร์กิวเมนต์นี้คือ
ใช้โดย Pegasus เมื่อมีการวางแผนเวิร์กโฟลว์ในโหมด PMC เท่านั้นเพื่ออำนวยความสะดวกในการดีบัก
และการเฝ้าติดตาม

--jobstate-เข้าสู่ระบบ
ตัวเลือกนี้ทำให้ PMC สร้างไฟล์ jobstate.log สำหรับเวิร์กโฟลว์ ไฟล์คือ
ชื่อ "jobstate.log" และวางไว้ในไดเร็กทอรีเดียวกันกับที่ไฟล์ DAG เป็น
ตั้งอยู่. หากไฟล์มีอยู่แล้ว PMC จะเพิ่มบรรทัดใหม่ต่อท้ายไฟล์ที่มีอยู่
Pegasus ใช้ตัวเลือกนี้เมื่อมีการวางแผนเวิร์กโฟลว์ในโหมด PMC เท่านั้นถึง
อำนวยความสะดวกในการตรวจสอบ

--monitord-แฮ็ค
ตัวเลือกนี้ทำให้ PMC สร้างไฟล์ .dagman.out สำหรับเวิร์กโฟลว์ ไฟล์นี้
เลียนแบบเนื้อหาของไฟล์ .dagman.out ที่สร้างโดย Condor DAGMan ประเด็นของ
ตัวเลือกนี้คือหลอกให้ผู้เฝ้าติดตามคิดว่ากำลังจัดการกับ DAGMan ดังนั้น
มันจะสร้างเหตุการณ์ที่เหมาะสมเพื่อเติมฐานข้อมูล STAMPEDE สำหรับ
วัตถุประสงค์ในการตรวจสอบ ไฟล์ชื่อ "DAG.dagman.out" โดยที่ "DAG" เป็นพาธไปยัง
ไฟล์ PMC DAG

--no-resource-เข้าสู่ระบบ
อย่าสร้าง เวิร์กโฟลว์.dag.resource ไฟล์สำหรับเวิร์กโฟลว์

--ไม่-นอน-on-recv
อย่าใช้การโพลด้วย sleep() เพื่อใช้งานการรับข้อความ (ดู ที่รู้จักกัน ปัญหาที่พบ: ซีพียู
การใช้)

--maxfds
ตั้งค่าจำนวนสูงสุดของ file descriptor ที่มาสเตอร์สามารถเปิดทิ้งไว้ได้สำหรับ I/O
การส่งต่อ โดยค่าเริ่มต้น ค่านี้จะถูกตั้งค่าโดยอัตโนมัติตามค่าของ
getrlimit(RLIMIT_NOFILE). ค่าต้องอย่างน้อย 1 และต้องไม่เกิน
RLIMIT_NOFILE

--รักษาความสัมพันธ์
โดยค่าเริ่มต้น PMC จะพยายามรีเซ็ตความสัมพันธ์ของ CPU และหน่วยความจำ ทั้งนี้เพื่อให้มั่นใจว่า
CPU และหน่วยความจำที่มีอยู่ทั้งหมดสามารถใช้โดยงาน PMC บนระบบที่ไม่ใช่
กำหนดค่าอย่างเหมาะสม แฟล็กนี้บอกให้ PMC เก็บการตั้งค่าความสัมพันธ์ที่สืบทอดมาจาก
ผู้ปกครองของมัน โปรดทราบว่านโยบายหน่วยความจำสามารถล้างได้ก็ต่อเมื่อรวบรวม PMC ด้วย
ลิบนูมา ความสัมพันธ์ของ CPU ถูกล้างโดยใช้ sched_setaffinity()และนโยบายหน่วยความจำคือ
เคลียร์ด้วย set_mempolicy().

DAG ไฟล์

เพกาซัส-mpi-คลัสเตอร์ เวิร์กโฟลว์จะแสดงโดยใช้รูปแบบข้อความธรรมดาที่คล้ายกับ
ที่ใช้โดย Condor DAGMan มีระเบียนเพียงสองประเภทที่อนุญาตในไฟล์ DAG: งาน
และ EDGE. บรรทัดว่างใน DAG (บรรทัดที่มีอักขระเว้นวรรคทั้งหมด) จะถูกละเว้น
เช่นเดียวกับบรรทัดใดๆ ที่ขึ้นต้นด้วย # (โปรดทราบว่า # สามารถปรากฏที่จุดเริ่มต้นของบรรทัดเท่านั้น
ไม่อยู่ตรงกลาง)

รูปแบบของ a งาน บันทึกคือ:

รหัส "TASK" [ตัวเลือก...] เรียกใช้งานได้ [อาร์กิวเมนต์...]

ที่ไหน id คือ ID ของงาน ตัวเลือก เป็นรายการตัวเลือกงาน ปฏิบัติการ คือเส้นทาง
ไปยังไฟล์ปฏิบัติการหรือสคริปต์ที่จะเรียกใช้และ ข้อโต้แย้ง... เป็นรายการที่คั่นด้วยช่องว่างของ
ข้อโต้แย้งที่จะส่งต่อไปยังงาน ตัวอย่างคือ:

งาน t01 -m 10 -c 2 /bin/program -a -b

ตัวอย่างนี้ระบุงาน t01 ที่ต้องใช้หน่วยความจำ 10 MB และ 2 CPU เพื่อรัน
/bin/โปรแกรม กับข้อโต้แย้ง -a และ -b. ตัวเลือกงานที่ใช้ได้คือ:

-m M, --request-หน่วยความจำ M
จำนวนหน่วยความจำที่งานต้องการในหน่วย MB ค่าเริ่มต้นคือ 0 ซึ่งหมายถึงหน่วยความจำ
ไม่ได้รับการพิจารณาสำหรับงานนี้ ตัวเลือกนี้สามารถตั้งค่าสำหรับงานใน DAX โดย
การระบุโปรไฟล์ pegasus::pmc_request_memory (ดู อิงจากทรัพยากร กำหนดการ)

-c N, --request-ซีพียู N
จำนวน CPU ที่งานต้องการ ค่าเริ่มต้นคือ 1 ซึ่งหมายความว่า
จำนวนสล็อตบนโฮสต์ควรน้อยกว่าหรือเท่ากับจำนวนฟิสิคัลซีพียู
เพื่อให้ทุกช่องใช้งานได้ ตัวเลือกนี้สามารถตั้งค่าสำหรับงานใน DAX โดย
การระบุโปรไฟล์ pegasus::pmc_request_cpus (ดู อิงจากทรัพยากร กำหนดการ)

-t T, --พยายาม T
จำนวนครั้งที่พยายามดำเนินการก่อนที่จะล้มเหลวอย่างถาวร นี้เป็น
เทียบเท่าระดับงานของ --พยายาม ตัวเลือกบรรทัดคำสั่ง

-p P, --ลำดับความสำคัญ P
ลำดับความสำคัญของงาน P ควรเป็นจำนวนเต็ม ค่าที่มากกว่าจะมีลำดับความสำคัญสูงกว่า
ค่าเริ่มต้นคือ 0 ลำดับความสำคัญเป็นเพียงคำใบ้และไม่เข้มงวด—หากงานไม่สามารถทำได้
ตรงกับช่องที่มีอยู่ (เช่นเนื่องจากความพร้อมของทรัพยากร) แต่ลำดับความสำคัญต่ำกว่า
งานสามารถ จากนั้นงานจะถูกเลื่อนออกไปและงานที่มีลำดับความสำคัญต่ำกว่าจะถูกดำเนินการ
ตัวเลือกนี้สามารถตั้งค่าสำหรับงานใน DAX ได้โดยการระบุ pegasus::pmc_priority
โปรไฟล์

-f VAR=ไฟล์, --ท่อไปข้างหน้า VAR=ไฟล์
ส่งต่อ I/O ไปยังไฟล์ ไฟล์ โดยใช้ท่อในการสื่อสารกับงาน สิ่งแวดล้อม
ตัวแปร VAR จะถูกตั้งค่าเป็น file descriptor สำหรับไพพ์ที่
งานสามารถเขียนเพื่อรับข้อมูลเข้า ไฟล์. ตัวอย่างเช่น หากงานระบุ: -f
FOO=/tmp/foo จากนั้นตัวแปรสภาพแวดล้อม FOO สำหรับงานจะถูกตั้งค่าเป็นตัวเลข
(เช่น 3) ที่แสดงถึงไฟล์ /tmp/foo. เพื่อระบุอาร์กิวเมนต์นี้ในa
Pegasus DAX คุณต้องตั้งค่าโปรไฟล์ pegasus::pmc_arguments (โปรดทราบว่าค่าของ
pmc_arguments ต้องมีส่วน "-f" ของอาร์กิวเมนต์ ดังนั้นค่าที่ถูกต้องจะเป็น:
-f A=/tmp/a ). (ดู I / O
ส่งต่อ)

-F SRC=ปลายทาง, --ไฟล์ส่งต่อ SRC=ปลายทาง
ส่งต่อ I/O ไปยังไฟล์ มือ จากไฟล์ SRC. เมื่องานเสร็จ ผู้ปฏิบัติงาน
จะอ่านข้อมูลจาก SRC และส่งให้อาจารย์ที่จะเขียนถึง
ไฟล์ มือ. หลังจากที่ SRC อ่านแล้วถูกลบ เพื่อระบุอาร์กิวเมนต์นี้ในa
Pegasus DAX คุณต้องตั้งค่าโปรไฟล์ pegasus::pmc_arguments (ดู I / O ส่งต่อ)

รูปแบบของ an EDGE บันทึกคือ:

"ขอบ" พ่อแม่ลูก

ที่ไหน ผู้ปกครอง คือ ID ของงานหลักและ เด็ก คือ ID ของงานย่อย หนึ่ง
ตัวอย่าง EDGE บันทึกคือ:

ขอบ t01 t02

เวิร์กโฟลว์รูปเพชรที่เรียบง่ายจะมีลักษณะดังนี้:

#เพชร.dag
งาน ก /bin/เสียงสะท้อน "ฉันเป็น"
งาน B /bin/เสียงสะท้อน “ฉันบี”
งาน C /bin/เสียงสะท้อน “ฉันซี”
งาน ง /bin/เสียงสะท้อน “ฉัน ดี”

EDGE AB
EDGE AC
ขอบ BD
ขอบซีดี

กู้ภัย ไฟล์

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

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

ไฟล์กู้ภัยมีระเบียน DONE XNUMX รายการขึ้นไป รูปแบบของบันทึกเหล่านี้คือ:

"เสร็จแล้ว" *งาน*

ที่ไหน งาน คือ ID ของงานที่ทำสำเร็จ

ตามค่าเริ่มต้น ไฟล์กู้ภัยจะมีชื่อว่า DAGNAME.rescue ที่ไหน แด๊กเนม เป็นเส้นทางสู่อินพุต
ไฟล์ DAG ชื่อไฟล์สามารถเปลี่ยนแปลงได้โดยการระบุ -r ข้อโต้แย้ง.

PMC AND PEGASUS

การใช้ PMC สำหรับ เพกาซัส งาน การจัดกลุ่ม
PMC สามารถใช้เป็น wrapper สำหรับงานคลัสเตอร์ใน Pegasus ในโหมดนี้
เพกาซัสจัดกลุ่มงานต่างๆ ไว้ด้วยกัน และส่งเป็นงานคลัสเตอร์เดียวไปยังa
ระบบระยะไกล จากนั้น PMC จะดำเนินการแต่ละงานในคลัสเตอร์และส่งคืน
ผล.

PMC สามารถระบุเป็นตัวจัดการงานสำหรับงานคลัสเตอร์ใน Pegasus ได้สามวิธี:

1. ทั่วโลกในไฟล์คุณสมบัติ

ผู้ใช้สามารถตั้งค่าคุณสมบัติในไฟล์คุณสมบัติที่ส่งผลให้คลัสเตอร์ทั้งหมด
งานของเวิร์กโฟลว์ที่ดำเนินการโดย PMC ในไฟล์คุณสมบัติ Pegasus ให้ระบุ:

#ไฟล์คุณสมบัติของเพกาซัส
pegasus.clusterer.job.aggregator=mpixec

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

2. โดยการตั้งค่าคีย์โปรไฟล์ "job.aggregator" ในแค็ตตาล็อกไซต์:


...
mpiexec


ในตัวอย่างข้างต้น งานคลัสเตอร์ทั้งหมดบน siteX จะถูกดำเนินการผ่าน
PMC ตราบใดที่ไม่มีการแทนที่ค่าในแค็ตตาล็อกการแปลง

3. โดยการตั้งค่าคีย์โปรไฟล์ "job.aggregator" ในแค็ตตาล็อกการแปลง:

tr ข {
ไซต์ siteX {
pfn "/path/to/mytask"
ซุ้มประตู "x86"
ระบบปฏิบัติการ "ลินุกซ์"
พิมพ์ "ติดตั้ง"
โปรไฟล์เพกาซัส "clusters.size" "3"
โปรไฟล์ pegasus "job.aggregator" "mpixec"
}
}

ในตัวอย่างข้างต้น งานคลัสเตอร์ทั้งหมดสำหรับการแปลง B บน siteX จะเป็น
ดำเนินการผ่าน PMC

โดยปกติจำเป็นต้องมีรายการ pegasus::mpixec ในแค็ตตาล็อกการแปลงของคุณ
ที่ระบุ a) เส้นทางไปยัง PMC บนไซต์ระยะไกลและ b) โปรไฟล์ลูกโลกที่เกี่ยวข้อง
เช่น xcount, host_xcount และ maxwalltime เพื่อควบคุมขนาดของงาน MPI รายการนั้น
จะมีลักษณะเช่นนี้:

tr เพกาซัส::mpixec {
ไซต์ siteX {
pfn "/path/to/pegasus-mpi-cluster"
ซุ้มประตู "x86"
ระบบปฏิบัติการ "ลินุกซ์"
พิมพ์ "ติดตั้ง"
ลูกโลกโปรไฟล์ "maxwalltime" "240"
ลูกโลกโปรไฟล์ "host_xcount" "1"
ลูกโลกโปรไฟล์ "xcount" "32"
}
}

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

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

เพกาซัส ดูรายละเอียด สำหรับ PMC
มีโปรไฟล์ Pegasus หลายโปรไฟล์ที่แมปกับตัวเลือกงาน PMC:

pmc_request_memory
โปรไฟล์นี้ใช้เพื่อตั้งค่าตัวเลือก --request-memory task และมักจะระบุไว้
ใน DAX หรือแค็ตตาล็อกการแปลง

pmc_request_cpus
คีย์นี้ใช้เพื่อตั้งค่าตัวเลือกงาน --request-cpus และมักจะระบุไว้ใน
DAX หรือแค็ตตาล็อกการแปลง

pmc_priority
คีย์นี้ใช้เพื่อตั้งค่าตัวเลือก --priority task และมักจะระบุไว้ใน
แด๊กซ์.

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

โปรไฟล์สามารถระบุได้ใน DAX ดังนี้:


-a 1 -b 2 -c 3
...
1024
4
10


ตัวอย่างนี้ระบุงาน PMC ที่ต้องการหน่วยความจำ 1GB และ 4 คอร์ และมี
ลำดับความสำคัญ 10 มันสร้างงานใน PMC DAG ที่มีลักษณะดังนี้:

งาน mytask_ID00000001 -m 1024 -c 4 -p 10 /path/to/mytask -a 1 -b 2 -c 3

การใช้ PMC สำหรับ ทั้งหมด เพกาซัส DAX
เพกาซัสยังสามารถกำหนดค่าให้รันเวิร์กโฟลว์ทั้งหมดเป็นงาน PMC เดียว ในเรื่องนี้
โหมด Pegasus จะสร้าง PMC DAG เดียวสำหรับเวิร์กโฟลว์ทั้งหมดรวมถึง PBS
สคริปต์ที่ใช้ส่งเวิร์กโฟลว์ได้

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

หากต้องการทำงานในโหมด PMC เท่านั้น ให้ตั้งค่าคุณสมบัติ "pegasus.code.generator" เป็น "PMC" ใน Pegasus
ไฟล์คุณสมบัติ:

pegasus.code.generator=PMC

ในการส่งงาน PBS ที่เป็นผลลัพธ์ คุณอาจต้องทำการเปลี่ยนแปลงไฟล์ .pbs
สร้างโดย Pegasus เพื่อให้ทำงานกับคลัสเตอร์ของคุณ โหมดนี้เป็นโหมดทดลองและ
ไม่ได้ใช้อย่างกว้างขวาง

เข้าสู่ระบบ

ตามค่าเริ่มต้น ข้อความบันทึกทั้งหมดจะถูกพิมพ์ไปที่ stderr หากคุณเปิดการบันทึกโดยใช้
-v จากนั้นคุณอาจจบลงด้วยการส่งต่อ stderr จากคนงานไปยัง
เจ้านาย

ระดับบันทึกโดยเรียงตามความรุนแรง ได้แก่ FATAL, ERROR, WARN, INFO, DEBUG และ TRACE

ระดับการบันทึกเริ่มต้นคือ INFO ระดับการบันทึกสามารถเพิ่มได้ด้วย -v และ
ลดลงด้วย -q.

งาน STDIUM

โดยค่าเริ่มต้น stdout และ stderr ของงานจะถูกเปลี่ยนเส้นทางไปยัง stdout ของมาสเตอร์และ
สเ คุณสามารถเปลี่ยนเส้นทางของไฟล์เหล่านี้ด้วยการ -o และ -e อาร์กิวเมนต์ นอกจากนี้คุณยังสามารถ
เปิดใช้งานไฟล์ stdio ต่องานโดยใช้ปุ่ม --ต่องาน-stdio การโต้แย้ง. โปรดทราบว่าถ้าต่องาน
ไม่ได้ใช้ไฟล์ stdio จากนั้น stdio ของผู้ปฏิบัติงานทั้งหมดจะถูกรวมเป็นหนึ่งเดียวและหนึ่ง
err ไฟล์โดยต้นแบบในตอนท้าย ดังนั้น I/O จากผู้ปฏิบัติงานที่แตกต่างกันจะไม่ถูกแทรกแซง
แต่ I/O จากผู้ปฏิบัติงานแต่ละคนจะปรากฏตามลำดับที่สร้างขึ้น นอกจากนี้โปรดทราบว่า
หากงานล้มเหลวด้วยเหตุผลใดก็ตาม ผลลัพธ์จะไม่ถูกรวมเข้าด้วยกัน แต่จะมี . แทน
หนึ่งไฟล์สำหรับผู้ปฏิบัติงานแต่ละคนชื่อ DAGFILE.out.X และ DAGFILE.err.X โดยที่ DAGFILE เป็นพาธ
ไปยังอินพุต DAG และ X คือยศกรรมกร

HOST สคริปต์

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

สคริปต์โฮสต์ถูกระบุโดยใช้คำสั่ง --host-สคริปต์ อาร์กิวเมนต์หรือ PMC_HOST_SCRIPT
ตัวแปรสภาพแวดล้อม

สคริปต์โฮสต์เริ่มต้นเมื่อ เพกาซัส-mpi-คลัสเตอร์ เริ่มต้นและต้องออกด้วยรหัสทางออก
ของ 0 ก่อนดำเนินการงานใดๆ หากเป็นสคริปต์โฮสต์ส่งคืนรหัสทางออกที่ไม่ใช่ศูนย์
จากนั้นเวิร์กโฟลว์จะถูกยกเลิก สคริปต์โฮสต์มีเวลา 60 วินาทีในการตั้งค่าใดๆ ที่เป็น
ที่จำเป็น. หากไม่ออกใน 60 วินาที สัญญาณ SIGALRM จะถูกส่งไปยัง
ซึ่งหากไม่ได้รับการจัดการจะทำให้กระบวนการยุติลง

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

อิงจากทรัพยากร กำหนดการ

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

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

หากไม่มีโฮสต์ที่พร้อมใช้งานที่มีหน่วยความจำและ CPU เพียงพอที่จะเรียกใช้หนึ่งใน
งานในเวิร์กโฟลว์ จากนั้นเวิร์กโฟลว์จะถูกยกเลิก

หน่วยความจำ
ผู้ใช้สามารถระบุทั้งจำนวนหน่วยความจำที่ต้องการต่องานและจำนวนหน่วยความจำ
ใช้ได้ต่อโฮสต์ หากจำนวนหน่วยความจำที่ต้องการโดยงานใด ๆ เกินที่มีอยู่
หน่วยความจำของโฮสต์ทั้งหมด จากนั้นเวิร์กโฟลว์จะถูกยกเลิก ตามค่าเริ่มต้น หน่วยความจำของโฮสต์คือ
กำหนดโดยอัตโนมัติอย่างไรก็ตามผู้ใช้สามารถระบุ --โฮสต์หน่วยความจำ ที่จะ "โกหก" ถึง
เพกาซัส-mpi-คลัสเตอร์. จำนวนหน่วยความจำที่จำเป็นสำหรับแต่ละงานระบุไว้ใน DAG
โดยใช้โปรแกรม -m/--request-หน่วยความจำ อาร์กิวเมนต์ (ดู DAG ไฟล์).

ซีพียู
ผู้ใช้สามารถระบุจำนวน CPU ที่ต้องการต่องาน และจำนวน CPU ทั้งหมด
ได้ในแต่ละโฮสต์ หากจำนวน CPU ที่งานต้องการเกินจำนวนที่มีอยู่
CPU บนโฮสต์ทั้งหมด จากนั้นเวิร์กโฟลว์จะถูกยกเลิก โดยค่าเริ่มต้น จำนวนของ CPU บน a
โฮสต์ถูกกำหนดโดยอัตโนมัติ แต่ผู้ใช้สามารถระบุ --โฮสต์ซีพียู มากกว่าหรือ
ภายใต้สมัครสมาชิกโฮสต์ จำนวน CPU ที่จำเป็นสำหรับแต่ละงานระบุไว้ใน
DAG โดยใช้ -c/--request-ซีพียู อาร์กิวเมนต์ (ดู DAG ไฟล์).

I / O ส่งต่อ

ในเวิร์กโฟลว์ที่มีงานเล็กๆ จำนวนมาก เป็นเรื่องปกติสำหรับ I/O ที่เขียนโดยงานเหล่านั้น
ที่จะมีขนาดเล็กมาก ตัวอย่างเช่น เวิร์กโฟลว์อาจมี 10,000 งานซึ่งแต่ละงานเขียนได้ไม่กี่ KB
ของข้อมูล โดยทั่วไปแล้วแต่ละงานจะเขียนลงในไฟล์ของตัวเอง ส่งผลให้มีไฟล์ 10,000 ไฟล์ I/O นี้
รูปแบบไม่มีประสิทธิภาพมากในระบบไฟล์คู่ขนานหลายระบบ เนื่องจากต้องใช้ file
ระบบเพื่อรองรับการดำเนินการ metadata จำนวนมาก ซึ่งเป็นปัญหาคอขวดในหลาย ๆ
ระบบไฟล์คู่ขนาน

วิธีหนึ่งในการจัดการปัญหานี้คือเขียนงานทั้งหมด 10,000 งานลงในไฟล์เดียว NS
ปัญหาของแนวทางนี้คือต้องให้งานเหล่านั้นซิงโครไนซ์การเข้าถึง
ไฟล์โดยใช้การล็อก POSIX หรือกลไกการยกเว้นร่วมกันอื่นๆ มิฉะนั้นจะเขียน
จากงานต่าง ๆ อาจถูกแทรกสลับตามลำดับโดยพลการ ส่งผลให้ข้อมูลใช้ไม่ได้

เพื่อจัดการกับกรณีการใช้งานนี้ PMC ใช้คุณลักษณะที่เราเรียกว่า "การส่งต่อ I/O"
การส่งต่อ I/O ช่วยให้แต่ละงานในงาน PMC สามารถเขียนข้อมูลไปยังจำนวน
ไฟล์ที่แชร์อย่างปลอดภัย โดยให้กระบวนการของผู้ปฏิบัติงาน PMC รวบรวมข้อมูล
เขียนโดยงานและส่งผ่านเครือข่ายความเร็วสูงโดยใช้ข้อความ MPI ไปที่
กระบวนการหลัก PMC ซึ่งเขียนไปยังไฟล์เอาต์พุต โดยมีกระบวนการเดียว (the
กระบวนการหลัก PMC) เขียนไฟล์ I/O ทั้งหมดจากงานแบบขนานจำนวนมากได้
ซิงโครไนซ์และเขียนลงในไฟล์อย่างปลอดภัย

มีสองวิธีที่แตกต่างกันในการใช้การส่งต่อ I/O ใน PMC: ไปป์และไฟล์ ท่อมีมากขึ้น
มีประสิทธิภาพ แต่ไฟล์ใช้งานง่ายกว่า

I / O ส่งต่อ ด้วย ท่อ
การส่งต่อ I/O ด้วยไพพ์ทำงานโดยให้กระบวนการของผู้ปฏิบัติงาน PMC รวบรวมข้อมูลจากแต่ละงาน
โดยใช้ท่อ UNIX วิธีนี้มีประสิทธิภาพมากกว่าวิธีการแบบไฟล์ แต่
ต้องการรหัสของงานที่จะเปลี่ยนเพื่อให้งานเขียนไปยังไพพ์แทน
ไฟล์ปกติ

เพื่อใช้งาน I/O ในการส่งต่องาน PMC เพียงแค่ต้องระบุ -f/--ไปป์-ไปข้างหน้า
อาร์กิวเมนต์เพื่อระบุชื่อของไฟล์ที่จะส่งต่อข้อมูลไปยังและชื่อของan
ตัวแปรสภาพแวดล้อมที่กระบวนการของผู้ปฏิบัติงาน PMC สามารถแจ้งไฟล์ได้
คำอธิบายสำหรับท่อ

ตัวอย่างเช่น หากมีงาน "mytask" ที่ต้องการส่งต่อข้อมูลไปยังสองไฟล์:
"myfile.a" และ "myfile.b" จะมีลักษณะดังนี้:

งาน mytask -f A=/tmp/myfile.a -f B=/tmp/myfile.b /bin/mytask

เมื่อกระบวนการ /bin/mytask เริ่มต้น จะมีสองตัวแปรในสภาพแวดล้อม: "A=3"
และ "B=4" เป็นต้น ค่าของตัวแปรเหล่านี้เป็นหมายเลขตัวอธิบายไฟล์ของ
ไฟล์ที่เกี่ยวข้อง ในกรณีนี้ หากงานต้องการเขียนไปยัง "/tmp/myfile.a" ก็จะได้รับ
ค่าของตัวแปรสภาพแวดล้อม "A" และเรียก write() บนหมายเลขตัวอธิบายนั้น ในC
รหัสสำหรับที่มีลักษณะดังนี้:

ถ่าน *A = getenv("A");
int fd = atoi(A);
ถ่าน *ข้อความ = "สวัสดี ชาวโลก\n";
เขียน (fd, ข้อความ, สเตรเลน(ข้อความ));

ในภาษาโปรแกรมบางภาษา ไม่สามารถเขียนไปยัง file descriptor โดยตรงได้
ตัวอย่างเช่น Fortran อ้างถึงไฟล์ตามหมายเลขหน่วยแทนที่จะใช้ตัวอธิบายไฟล์ ใน
ภาษาเหล่านี้คุณสามารถเชื่อมโยงฟังก์ชัน CI/O ลงในไบนารีของคุณและเรียกจาก
รูทีนที่เขียนเป็นภาษาอื่นหรือคุณสามารถเปิดไฟล์พิเศษใน Linux / proc
ระบบไฟล์เพื่อรับการจัดการอื่นไปยังไพพ์ที่คุณต้องการเข้าถึง อย่างหลัง ไฟล์
คุณควรเปิดคือ "/proc/self/fd/NUMBER" โดยที่ NUMBER คือหมายเลขตัวอธิบายไฟล์ของคุณ
ได้จากตัวแปรสภาพแวดล้อม สำหรับตัวอย่างข้างต้น ไปป์สำหรับ myfile.a
(ตัวแปรสภาพแวดล้อม A) คือ "/proc/self/fd/3"

หากคุณกำลังใช้ เพกาซัส-kickstartซึ่งน่าจะเป็นกรณีที่คุณใช้ PMC สำหรับ a
ขั้นตอนการทำงานของ Pegasus มีเคล็ดลับที่คุณสามารถทำได้เพื่อหลีกเลี่ยงการแก้ไขโค้ดของคุณ คุณใช้
/ proc ระบบไฟล์ตามที่อธิบายไว้ข้างต้น แต่คุณให้ pegasus-kickstart จัดการเส้นทาง
การก่อสร้าง. ตัวอย่างเช่น หากแอปพลิเคชันของคุณมีอาร์กิวเมนต์ -o ที่อนุญาตให้คุณ
ระบุไฟล์เอาต์พุต จากนั้นคุณสามารถเขียนงานของคุณดังนี้:

งาน mytask -f A=/tmp/myfile.a /bin/pegasus-kickstart /bin/mytask -o /proc/ตัวเอง/fd/$A

ในกรณีนี้ pegasus-kickstart จะแทนที่ $A ในอาร์กิวเมนต์แอปพลิเคชันของคุณด้วย
file descriptor หมายเลขที่คุณต้องการ รหัสของคุณสามารถเปิดเส้นทางนั้นได้ตามปกติ เขียนลงไป และ
แล้วปิดเหมือนเป็นไฟล์ปกติ

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

สามารถเปิดใช้งานการส่งต่อไฟล์ได้โดยให้ -F/--ไฟล์-ส่งต่อ อาร์กิวเมนต์ในงาน

นี่คือตัวอย่าง:

งาน mytask -F /tmp/foo.0=/scratch/foo /bin/mytask -o /tmp/foo.0

ในกรณีนี้ กระบวนการของผู้ปฏิบัติงานคาดว่าจะพบไฟล์ /tmp/foo.0 เมื่อ mytask ออก
ได้สำเร็จ มันอ่านข้อมูลจากไฟล์นั้นและส่งไปยังต้นแบบเพื่อเขียนถึง
จุดสิ้นสุดของ /scratch/foo หลังจากอ่าน /tmp/foo.0 แล้ว ผู้ปฏิบัติงานจะลบทิ้งไป
กระบวนการ

วิธีนี้ใช้ได้ผลดีที่สุดกับระบบที่ดิสก์ในเครื่องเป็นระบบไฟล์ RAM เช่น Cray
เครื่องเอ็กซ์ที อีกทางหนึ่งงานสามารถใช้ /dev/shm บนคลัสเตอร์ Linux ปกติ มันอาจจะ
ยังทำงานค่อนข้างมีประสิทธิภาพบนดิสก์ภายในเครื่องหากแคชของระบบไฟล์สามารถ
ซึมซับการอ่านและเขียนทั้งหมด

I / O ส่งต่อ คำเตือน
เมื่อใช้การส่งต่อ I/O ควรพิจารณาข้อควรระวังบางประการ

ขั้นแรก ถ้างาน PMC ล้มเหลวด้วยเหตุผลใดก็ตาม (รวมถึงเมื่อเวิร์กโฟลว์ถูกยกเลิกสำหรับ
การละเมิด --max-wall-time) ดังนั้นไฟล์ที่มี I/O ที่ส่งต่ออาจเสียหาย พวกเขา
สามารถรวม เพียงบางส่วน บันทึกหมายความว่ามีเพียงส่วนหนึ่งของ I/O จากงานหนึ่งงานขึ้นไปคือ
เขียนและสามารถรวม ซ้ำ บันทึกหมายความว่า I/O ถูกเขียนขึ้น แต่
งาน PMC ล้มเหลวก่อนที่งานจะถูกทำเครื่องหมายว่าสำเร็จ และเวิร์กโฟลว์เป็น
เริ่มใหม่ในภายหลัง เราไม่รับประกันเกี่ยวกับเนื้อหาของไฟล์ข้อมูลในกรณีนี้
มันขึ้นอยู่กับรหัสที่อ่านไฟล์ไปยัง a) ตรวจจับและ b) กู้คืนจากปัญหาดังกล่าว
เพื่อกำจัดรายการที่ซ้ำกัน เร็กคอร์ดควรมีตัวระบุที่ไม่ซ้ำกัน และเพื่อกำจัด
บางส่วนของระเบียนควรมีการตรวจสอบ

ประการที่สอง คุณไม่ควรใช้การส่งต่อ I/O หากงานของคุณกำลังจะเขียนข้อมูลจำนวนมากไปยัง
ไฟล์. เนื่องจากพนักงาน PMC กำลังอ่านข้อมูลนอกไพพ์/ไฟล์ไปยังหน่วยความจำและส่ง
มันอยู่ในข้อความ MPI ถ้าคุณเขียนมากเกินไป กระบวนการของผู้ปฏิบัติงานจะเรียกใช้ระบบ
ความจำเต็ม. นอกจากนี้ ข้อมูลทั้งหมดต้องพอดีกับข้อความ MPI เดียว ในการส่งต่อท่อ
ไม่มีการจำกัดขนาดฮาร์ด แต่ในการส่งต่อไฟล์ ขีดจำกัดคือ 1MB เราไม่ได้
เปรียบเทียบประสิทธิภาพกับ I/O ขนาดใหญ่ แต่อะไรที่ใหญ่กว่าประมาณ 1 MB ก็น่าจะเป็น
มากเกินไป ยังไงก็ตาม หากข้อมูลของคุณมีขนาดใหญ่กว่า 1MB การส่งต่อ I/O อาจจะไม่
มีประโยชน์ด้านประสิทธิภาพมากอยู่แล้ว

ประการที่สาม I/O จะไม่ถูกเขียนลงในไฟล์หากงานส่งคืนรหัสทางออกที่ไม่ใช่ศูนย์ เรา
สมมติว่าถ้างานล้มเหลว แสดงว่าคุณไม่ต้องการให้ข้อมูลสร้าง

ประการที่สี่ ข้อมูลจากงานต่างๆ จะไม่ถูกสอดแทรก ข้อมูลทั้งหมดที่เขียนโดย a
งานที่กำหนดจะปรากฏตามลำดับในไฟล์ที่ส่งออก โปรดทราบว่าคุณยังสามารถรับ
บันทึกบางส่วน แต่ถ้าข้อมูลใด ๆ จากงานปรากฏจะไม่ถูกแบ่งระหว่าง
ช่วงที่ไม่อยู่ติดกันในไฟล์เอาต์พุต หากคุณมี 3 งานที่เขียนว่า "I am a task" คุณ
สามารถรับ:

ฉันคืองาน ฉันคืองาน ฉันคืองาน

และ:

ฉันเป็นงานฉันเป็นงาน

แต่ไม่:

ฉันเป็นงาน ฉันเป็นงาน เป็นงาน

ประการที่ห้า ข้อมูลจากงานต่างๆ ปรากฏในลำดับที่ต้องการในไฟล์เอาต์พุต มันขึ้นอยู่กับ
PMC ดำเนินการตามลำดับงานใด ซึ่งอาจกำหนดได้โดยพลการหากไม่มี
การพึ่งพากันระหว่างงาน ข้อมูลที่เขียนควรมีข้อมูลเพียงพอ
ที่คุณสามารถกำหนดได้ว่างานใดที่ผลิตขึ้นหากคุณต้องการ PMC ไม่
เพิ่มส่วนหัวหรือส่วนท้ายลงในข้อมูล

ประการที่หก งานจะถูกทำเครื่องหมายว่าสำเร็จก็ต่อเมื่อ I/O ทั้งหมดสำเร็จ
เขียนไว้. หากเวิร์กโฟลว์เสร็จสมบูรณ์แล้ว I/O ได้รับการรับประกันว่าจะเป็น
เขียนไว้.

ประการที่เจ็ด ถ้าต้นแบบไม่สามารถเขียนไปยังไฟล์ที่ส่งออกได้ด้วยเหตุผลใดก็ตาม (เช่น
ต้นแบบพยายามเขียน I/O ไปยังไฟล์ปลายทาง แต่การเรียก write() จะส่งคืน an
ข้อผิดพลาด) จากนั้นงานจะถูกทำเครื่องหมายว่าล้มเหลวแม้ว่างานจะสร้างรหัสทางออกที่ไม่ใช่ศูนย์ ใน
กล่าวอีกนัยหนึ่ง คุณอาจได้รับบันทึกการเริ่มต้นที่ไม่เป็นศูนย์แม้ว่า PMC จะทำเครื่องหมายว่างานล้มเหลว

แปด ท่อเป็นแบบเขียนอย่างเดียว หากคุณต้องการอ่านและเขียนข้อมูลจากไฟล์คุณ
ควรใช้การส่งต่อไฟล์ไม่ใช่การส่งต่อไปป์

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

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

อื่น ๆ

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

ที่รู้จักกัน ประเด็น

ส้อม() และ ผู้บริหาร ()
เพื่อให้กระบวนการของผู้ปฏิบัติงานเริ่มงานบนโหนดคอมพิวท์ โหนดคอมพิวท์
ต้องรองรับไฟล์ ส้อม() และ ผู้บริหาร () การโทรของระบบ หากเครื่องเป้าหมายของคุณทำงาน a
OS แบบแยกส่วนบนโหนดคอมพิวท์ที่ไม่รองรับการเรียกระบบเหล่านี้ จากนั้น
เพกาซัส-mpi-คลัสเตอร์ จะไม่ทำงาน.

ซีพียู การใช้
การใช้งาน MPI จำนวนมากได้รับการปรับให้เหมาะสมเพื่อให้ข้อความส่งและรับโดยไม่ต้องรอ
(เช่นพวกเขาหมุน/โพลในข้อความที่ส่งหรือรับแทนที่จะนอนหลับ) การให้เหตุผลคือ
ที่การนอนหลับเพิ่มค่าใช้จ่ายและเนื่องจากระบบ HPC จำนวนมากใช้การแชร์พื้นที่บนเฉพาะ
ฮาร์ดแวร์ไม่มีกระบวนการอื่นที่แข่งขันกัน ดังนั้นการหมุนแทนการนอนสามารถ
ให้ประสิทธิภาพที่ดีขึ้น ในการใช้งานเหล่านั้น กระบวนการ MPI จะทำงานที่ CPU 100%
การใช้งานแม้ในขณะที่พวกเขากำลังรอข้อความ นี่เป็นปัญหาใหญ่สำหรับมัลติคอร์
งานใน เพกาซัส-mpi-คลัสเตอร์ เนื่องจากสล็อตว่างใช้ทรัพยากรของ CPU เพื่อที่จะแก้
ปัญหานี้ เพกาซัส-mpi-คลัสเตอร์ ประมวลผลการนอนหลับในช่วงเวลาสั้น ๆ ระหว่างการตรวจสอบสำหรับ
ข้อความรอ ซึ่งจะช่วยลดภาระได้อย่างมาก แต่ทำให้เกิดความล่าช้าใน
รับข้อความ หากคุณกำลังใช้การใช้งาน MPI ที่สลีปในการส่งข้อความและ
รับแทนการรอที่วุ่นวาย จากนั้นคุณสามารถปิดการใช้งานโหมดสลีปโดยระบุ
--ไม่-นอน-on-recv ตัวเลือก. โปรดทราบว่าอาจารย์จะหลับเสมอถ้า --max-wall-time is
ระบุไว้เพราะไม่มีทางที่จะขัดจังหวะหรือหมดเวลาการโทรบล็อกในMPI
(เช่น SIGALRM ไม่ทำให้ MPI_Recv ส่งคืน EINTR)

และพวกเรา ตัวแปร

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

PMC_HOST_SCRIPT
นามแฝงสำหรับ --host-สคริปต์ ตัวเลือก

PMC_HOST_MEMORY
นามแฝงสำหรับ --โฮสต์หน่วยความจำ ตัวเลือก

PMC_HOST_CPUS
นามแฝงสำหรับ --โฮสต์ซีพียู ตัวเลือก

PMC_MAX_WALL_TIME
นามแฝงสำหรับ --max-wall-time ตัวเลือก

ใช้ pegasus-mpi-cluster ออนไลน์โดยใช้บริการ onworks.net