จะเกิดอะไรขึ้นถ้าฉันเริ่มงานพื้นหลังมากเกินไป

ฉันต้องทำงานกับอุปกรณ์เครือข่าย 700 ชิ้นโดยใช้สคริปต์ที่คาดไว้ ฉันสามารถทำได้ตามลำดับ แต่จนถึงขณะนี้รันไทม์ประมาณ 24 ชั่วโมง นี่คือสาเหตุส่วนใหญ่เนื่องจากเวลาที่ใช้ในการสร้างการเชื่อมต่อและความล่าช้าในผลลัพธ์จากอุปกรณ์เหล่านี้ (เก่า) ฉันสามารถสร้างการเชื่อมต่อที่สองและให้พวกเขาทำงานแบบขนานได้ดี แต่ฉันจะผลักมันไปได้ไกลแค่ไหน?

ฉันไม่คิดว่าฉันสามารถทำทั้งหมด 700 ครั้งได้แน่นอนมีข้อ จำกัด บางอย่าง ของการเชื่อมต่อ telnet VM ของฉันสามารถจัดการได้

ถ้าฉันพยายามเริ่ม 700 ของพวกเขาในการวนรอบบางอย่างเช่นนี้:

for node in `ls ~/sagLogs/`; do  
    foo &  
done

กับ

• CPU 12 CPUs x Intel (R) Xeon (R) CPU E5649 @ 2.53GHz

• หน่วยความจำ 47.94 GB

คำถามของฉันคือ:

1. อินสแตนซ์ทั้งหมด 700 รายการอาจทำงานพร้อมกันได้หรือไม่
2. ฉันจะไปได้ไกลแค่ไหนจนกระทั่งเซิร์ฟเวอร์ถึงขีด จำกัด ?
3. เมื่อถึงขีด จำกัด นั้นจะต้องรอเพื่อเริ่มการทำซ้ำครั้งถัดไปfooหรือกล่องเกิดปัญหาหรือไม่

ฉันทำงานในสภาพแวดล้อมการผลิตขององค์กรโชคไม่ดีดังนั้นฉันจึงไม่สามารถลองและดูว่าเกิดอะไรขึ้น

อินสแตนซ์ทั้งหมด 700 รายการอาจทำงานพร้อมกันได้หรือไม่

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

ฉันจะไปได้ไกลแค่ไหนจนกระทั่งเซิร์ฟเวอร์ถึงขีด จำกัด ?

นี่เป็นไปไม่ได้ที่จะตอบเป็นรูปธรรมโดยไม่มีข้อมูลมากขึ้น ค่อนข้างมากคุณต้องมีหน่วยความจำเพียงพอที่จะตอบสนอง:

• ข้อกำหนดหน่วยความจำรันไทม์ทั้งหมดของหนึ่งงานคูณ 700
• ข้อกำหนดหน่วยความจำของ bash เพื่อจัดการว่ามีงานจำนวนมาก (bash นั้นไม่น่ากลัวเกี่ยวกับเรื่องนี้ แต่การควบคุมงานนั้นไม่ได้มีประสิทธิภาพเพียงพอสำหรับหน่วยความจำ)
• ข้อกำหนดหน่วยความจำอื่น ๆ บนระบบ

สมมติว่าคุณพบสิ่งนั้น (อีกครั้งด้วย RAM เพียง 50GB คุณยังต้องเผชิญกับปัญหาอื่น ๆ :

• ต้องเสียเวลา CPU มากเพียงใดในการควบคุมงาน? อาจจะไม่มากนัก แต่มีงานหลายร้อยตำแหน่ง
• จำเป็นต้องใช้แบนด์วิดท์เครือข่ายเท่าใด เพียงแค่เปิดการเชื่อมต่อเหล่านั้นทั้งหมดอาจทำให้เครือข่ายของคุณเสียหายประมาณสองสามนาทีขึ้นอยู่กับแบนด์วิดท์และเวลาแฝงของคุณ
• สิ่งอื่น ๆ อีกมากมายที่ฉันอาจไม่ได้คิด

เมื่อถึงขีด จำกัด นั้นแล้วจะรอเพื่อเริ่มต้นการทำซ้ำครั้งถัดไปจาก foo หรือกล่องจะพังหรือไม่

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

สิ่งที่คุณต้องการจริงๆที่นี่ไม่ใช่การทำงานทั้งหมดในเวลาเดียวกัน แต่ให้แบ่งออกเป็นแบทช์และรันงานทั้งหมดภายในแบทช์ในเวลาเดียวกันปล่อยให้งานนั้นเสร็จสิ้นจากนั้นเริ่มแบทช์ต่อไป GNU Parallel ( https://www.gnu.org/software/parallel/ ) สามารถใช้สำหรับสิ่งนี้ได้ แต่มันก็น้อยกว่าอุดมคติในระดับนั้นในสภาพแวดล้อมการผลิต (ถ้าคุณไปด้วยอย่าก้าวร้าวเกินไป) อย่างที่ฉันพูดไว้คุณอาจล้นเครือข่ายและส่งผลกระทบต่อระบบที่คุณไม่ต้องการแตะต้อง) ฉันอยากจะแนะนำให้มองหาเครื่องมือตรวจสอบเครือข่ายที่เหมาะสมเช่น Ansible ( https://www.ansible.com/) เนื่องจากจะไม่เพียง แต่แก้ปัญหาการทำงานพร้อมกันของคุณ (Ansible จะทำการแบตช์อย่างที่ฉันได้กล่าวไว้ข้างต้นโดยอัตโนมัติ) แต่ยังให้คุณสมบัติที่มีประโยชน์อื่น ๆ อีกมากมายให้คุณทำงานด้วย (เช่นการทำงาน idempotent เครื่องมืออื่น ๆ จำนวนมาก)

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

ฉันขอแนะนำให้คุณใช้ GNU ขนาน ( https://www.gnu.org/software/parallel/ ) หรือสิ่งที่คล้ายกันเพื่อให้บรรลุสิ่งนี้หรือไม่ มันจะทำให้คุณได้เปรียบหลายอย่างกับวิธีการทำงานแบบเบื้องหลัง:

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

ดูที่นี่เพื่อเริ่มต้นอย่างรวดเร็ว: https://www.gnu.org/software/parallel/parallel_tutorial.html#A-single-input-source

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

ls ~/sagLogs/ | parallel --delay 0.5 --memfree 1G -j0 --joblog my.log --retries 10 foo {}

นี้จะทำงานสำหรับแต่ละไฟล์ในfoo ~/sagLogsมันเริ่มงานทุก ๆ 0.5 วินาทีมันจะทำงานหลายขนานพร้อมกันตราบเท่าที่ 1 GB RAM ว่าง แต่จะเคารพข้อ จำกัด ของระบบของคุณ (เช่นจำนวนไฟล์และกระบวนการ) โดยทั่วไปหมายความว่าคุณจะทำงาน 250 งานพร้อมกันหากคุณไม่ได้ปรับจำนวนไฟล์ที่อนุญาตให้เปิด หากคุณปรับจำนวนไฟล์ที่เปิดอยู่คุณไม่ควรมีปัญหาในการใช้งาน 32000 แบบขนาน - ตราบใดที่คุณมีหน่วยความจำเพียงพอ

หากงานล้มเหลว (เช่นกลับมาพร้อมรหัสข้อผิดพลาด) มันจะถูกลองใหม่ 10 ครั้ง

my.log จะบอกคุณว่างานสำเร็จหรือไม่ (หลังจากลองอีกครั้ง) หรือไม่

จะเกิดอะไรขึ้นถ้าฉันเริ่มงานพื้นหลังมากเกินไป

ระบบจะช้าและไม่ตอบสนองกรณีที่เลวร้ายที่สุดคือไม่ตอบสนองมันจะเป็นการดีที่สุดที่จะเพียงกดปุ่มเปิดปิดและทำการรีบูตอย่างหนัก ... นี่จะเป็นการใช้งานบางอย่างในฐานะรูทซึ่งมีสิทธิพิเศษในการทำเช่นนั้น หากสคริปต์ทุบตีของคุณทำงานภายใต้สิทธิ์ของผู้ใช้ปกติสิ่งแรกที่ควรคำนึงถึงคือ/etc/security/limits.confและ/etc/systemd/system.confตัวแปรทั้งหมดใน [พูดแบบนึกคิด] ป้องกัน ผู้ใช้จากการโหลดระบบมากเกินไป

• cpu = xeon E5649 นั่นคือซีพียู12 คอร์ ; ดังนั้นคุณมี 12 คอร์สำหรับ 12 กระบวนการเพื่อให้ทำงานพร้อมกันโดยใช้หนึ่งในสิบสองคอร์ที่ 100% หากคุณเริ่มกระบวนการ 24 กระบวนการแต่ละกระบวนการจะทำงานที่อัตราการใช้ประโยชน์ 50% ในแต่ละสิบสองคอร์ 700 กระบวนการ = 1.7% แต่เป็นคอมพิวเตอร์ตราบใดที่ทุกอย่างเสร็จสมบูรณ์อย่างถูกต้องในระยะเวลาที่เหมาะสมและประสบความสำเร็จ ความมีประสิทธิภาพไม่เกี่ยวข้องเสมอไป

  1. อินสแตนซ์ทั้งหมด 700 รายการอาจทำงานพร้อมกันได้หรือไม่ แน่นอนว่า 700 ไม่ใช่จำนวนมาก maxprocตัวอย่าง /etc/security/limits.conf ของฉันคือ 4,135,275 ตัวอย่างเช่น

  2. ฉันจะไปได้ไกลแค่ไหนจนกระทั่งเซิร์ฟเวอร์ถึงขีด จำกัด ? ไกลกว่า 700 ฉันแน่ใจ

  3. จำกัด ... จะเกิดอะไรขึ้นถ้าสคริปต์ถูกเตะภายใต้บัญชีผู้ใช้ [และโดยทั่วไปจะlimits.confมีผลกับทุกคนมาก] คือสคริปต์จะออกหลังจากพยายามทำfoo &700 ครั้ง; คุณคาดว่าจะเห็น 700 fooดำเนินการแต่ละอันด้วย pid ที่แตกต่างกัน แต่คุณอาจเห็นเพียง 456 (ตัวเลือกตัวเลขสุ่ม) และอีก 244 ไม่เคยเริ่มต้นเพราะพวกเขาถูกบล็อกด้วยความปลอดภัยหรือ จำกัด systemd

คำถามล้าน $: คุณควรวิ่งไปพร้อมกันกี่คน?

การมีส่วนร่วมกับเครือข่ายและคุณบอกว่าแต่ละคนจะทำการเชื่อมต่อ telnet การศึกษาที่เดาได้คือคุณจะใช้งานเครือข่ายและค่าใช้จ่ายก่อนที่คุณจะทำเพื่อซีพียูและแรม แต่ฉันไม่รู้ว่าคุณกำลังทำอะไรโดยเฉพาะสิ่งที่จะเกิดขึ้นคือคุณสามารถเริ่มต้นทั้งหมด 700 ครั้ง แต่สิ่งต่าง ๆ จะปิดกั้นโดยอัตโนมัติจนกว่ากระบวนการก่อนหน้าและการเชื่อมต่อเครือข่ายจะเสร็จสิ้นและปิดโดยขึ้นอยู่กับขีด จำกัด ของระบบต่างๆ 500 ครั้งแรกจะเริ่มต้นใหม่ส่วนที่เหลืออีก 200 ครั้งจะไม่เกิดขึ้นเนื่องจากขีด จำกัด ของระบบหรือเคอร์เนลป้องกัน แต่อย่างไรก็ตามหลายคนวิ่งพร้อมกันจะมีความหวานจุดที่ต้องทำให้เสร็จเร็วที่สุดเท่าที่จะเป็นไปได้ ... ลดค่าใช้จ่ายและเพิ่มประสิทธิภาพ เป็น 12 คอร์ (หรือ 24 ถ้าคุณมีซีพียู 2 ตัว) จากนั้นเริ่มด้วย 12 (หรือ 24) ในคราวเดียวแล้วเพิ่มหมายเลขแบตช์พร้อมกันนั้น 12 หรือ 24 จนกว่าคุณจะไม่เห็นการปรับปรุงเวลาทำงาน

คำใบ้: การเชื่อมต่อ telnet ของ google maxและดูว่าสิ่งนี้มีผลกับระบบของคุณอย่างไร นอกจากนี้อย่าลืมไฟร์วอลล์ ทำการคำนวณหน่วยความจำที่รวดเร็วต่อกระบวนการ x 700 ตรวจสอบให้แน่ใจว่า <RAM พร้อมใช้งาน (ประมาณ 50GB ในกรณีของคุณ) มิฉะนั้นระบบจะเริ่มใช้ SWAP และโดยทั่วไปจะไม่ตอบสนอง ดังนั้นเตะ 12, 24, Nกระบวนการในแต่ละครั้งและตรวจสอบ RAM ฟรีจากนั้นเพิ่มN ที่มีความรู้เกี่ยวกับสิ่งที่เกิดขึ้นแล้ว

โดยค่าเริ่มต้น RHEL จำกัด จำนวนการเชื่อมต่อ telnet จากโฮสต์เดียวถึง 10 เซสชันพร้อมกัน นี่คือคุณลักษณะด้านความปลอดภัย ... ตั้งค่าเป็น 10, /etc/xinetd.conf เปลี่ยนค่า“ per_source”