ในทางเทคนิคเหตุใดกระบวนการใน Erlang จึงมีประสิทธิภาพมากกว่าเธรด OS

ลักษณะของ Erlang

จากการเขียนโปรแกรม Erlang (2009):

การทำงานพร้อมกันของ Erlang นั้นรวดเร็วและสามารถปรับขนาดได้ กระบวนการมีน้ำหนักเบาซึ่งเครื่องเสมือน Erlang ไม่ได้สร้างเธรด OS สำหรับทุกกระบวนการที่สร้างขึ้น พวกเขาถูกสร้างกำหนดเวลาและจัดการใน VM เป็นอิสระจากระบบปฏิบัติการพื้นฐาน เป็นผลให้เวลาการสร้างกระบวนการเป็นลำดับไมโครวินาทีและเป็นอิสระจากจำนวนกระบวนการที่มีอยู่พร้อมกัน เปรียบเทียบสิ่งนี้กับ Java และ C # ซึ่งทุกขั้นตอนจะสร้างเธรด OS พื้นฐานขึ้นมา: คุณจะได้รับการเปรียบเทียบที่แข่งขันได้มากโดย Erlang มีประสิทธิภาพเหนือกว่าทั้งสองภาษา

จากการเขียนโปรแกรมเชิง Concurrency ใน Erlang (pdf) (สไลด์) (2003):

เราสังเกตว่าเวลาที่ใช้ในการสร้างกระบวนการ Erlang นั้นมีค่าคงที่ 1 ถึง 2,500 กระบวนการ; หลังจากนั้นจะเพิ่มขึ้นเป็นประมาณ 3 วินาทีสำหรับกระบวนการมากถึง 30,000 กระบวนการ ประสิทธิภาพของ Java และ C # จะแสดงที่ด้านบนของภาพ สำหรับกระบวนการจำนวนน้อยจะใช้เวลาประมาณ 300 วินาทีในการสร้างกระบวนการ การสร้างกระบวนการมากกว่าสองพันรายการเป็นไปไม่ได้

เราเห็นว่าสำหรับกระบวนการมากถึง 30,000 กระบวนการเวลาในการส่งข้อความระหว่างสองกระบวนการของ Erlang นั้นประมาณ 0.8µs สำหรับ C # ใช้เวลาประมาณ 50 ต่อข้อความขึ้นกับจำนวนสูงสุดของกระบวนการ (ซึ่งประมาณ 1800 กระบวนการ) Java ยิ่งแย่ลงสำหรับกระบวนการมากถึง 100 กระบวนการนั้นใช้เวลาประมาณ 50 ต่อข้อความหลังจากนั้นจะเพิ่มขึ้นอย่างรวดเร็วเป็น 10ms ต่อข้อความเมื่อมีกระบวนการ Java ประมาณ 1,000 กระบวนการ

ความคิดของฉัน

ฉันไม่เข้าใจอย่างถ่องแท้ในทางเทคนิคว่าเหตุใดกระบวนการ Erlang จึงมีประสิทธิภาพมากกว่าในการวางไข่กระบวนการใหม่และมี footprints หน่วยความจำที่เล็กลงต่อกระบวนการ ทั้งระบบปฏิบัติการและ Erlang VM ต้องทำการตั้งเวลาสลับบริบทและติดตามค่าในรีจิสเตอร์และอื่น ๆ ...

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

ในทางเทคนิคเหตุใดกระบวนการใน Erlang จึงมีประสิทธิภาพมากกว่าเธรด OS เมื่อพูดถึงการวางไข่และการสื่อสาร และทำไมไม่สามารถใช้งานและจัดการเธรดในระบบปฏิบัติการได้อย่างมีประสิทธิภาพเหมือนกัน? และทำไมเธรด OS จึงมีหน่วยความจำขนาดใหญ่กว่ารวมถึงการวางไข่และการสื่อสารที่ช้าลง

อ่านเพิ่มเติม

• ภายใน Erlang VM โดยมุ่งเน้นที่ SMP (2008)
• เห็นพ้องด้วยใน Java และใน Erlang (pdf) (2004)
• การวัดประสิทธิภาพของเธรดใน Java และกระบวนการใน Erlang (1998)

มีปัจจัยสนับสนุนหลายประการ:

1. กระบวนการ Erlang ไม่ใช่กระบวนการของระบบปฏิบัติการ มีการใช้งานโดย Erlang VM โดยใช้โมเดลการทำเธรดสหกรณ์แบบมีน้ำหนักเบา (ยึดเอาเสียก่อนที่ระดับ Erlang แต่อยู่ภายใต้การควบคุมของรันไทม์ที่จัดกำหนดการแบบร่วมมือกัน) ซึ่งหมายความว่ามันถูกกว่ามากในการสลับบริบทเนื่องจากพวกเขาสลับเฉพาะจุดที่รู้จักและควบคุมดังนั้นจึงไม่จำเป็นต้องบันทึกสถานะ CPU ทั้งหมด (ลงทะเบียน SSE และ FPU ปกติ, การจับคู่พื้นที่ที่อยู่ ฯลฯ )
2. กระบวนการ Erlang ใช้สแต็กที่จัดสรรแบบไดนามิกซึ่งเริ่มต้นเล็กมากและเติบโตตามความจำเป็น สิ่งนี้อนุญาตให้มีการวางไข่ของกระบวนการ Erlang หลายพัน - แม้แต่ล้าน - กระบวนการโดยไม่ดูด RAM ที่มีอยู่ทั้งหมด
3. Erlang เคยเป็นเธรดเดี่ยวซึ่งหมายความว่าไม่มีข้อกำหนดเพื่อให้มั่นใจถึงความปลอดภัยของเธรดระหว่างกระบวนการ ตอนนี้รองรับ SMP แต่การทำงานร่วมกันระหว่างกระบวนการ Erlang ในตัวกำหนดตารางเวลา / แกนเดียวกันยังคงมีน้ำหนักเบามาก (มีคิวการรันแยกกันต่อคอร์)

หลังจากการวิจัยเพิ่มเติมฉันพบการนำเสนอโดย Joe Armstrong

จากErlang - ซอฟต์แวร์สำหรับโลกที่เกิดขึ้นพร้อมกัน (การนำเสนอ) (เวลา 13 นาที):

[Erlang] เป็นภาษาที่เกิดขึ้นพร้อมกันโดยที่ฉันหมายความว่าเธรดเป็นส่วนหนึ่งของภาษาการเขียนโปรแกรมซึ่งไม่ได้เป็นของระบบปฏิบัติการ นั่นเป็นสิ่งที่ผิดปกติกับภาษาการเขียนโปรแกรมเช่น Java และ C ++ มันเป็นเธรดที่ไม่ได้อยู่ในภาษาการเขียนโปรแกรมเธรดเป็นสิ่งที่อยู่ในระบบปฏิบัติการและพวกเขาสืบทอดปัญหาทั้งหมดที่มีในระบบปฏิบัติการ หนึ่งในปัญหาคือความละเอียดของระบบการจัดการหน่วยความจำ การจัดการหน่วยความจำในระบบปฏิบัติการป้องกันหน่วยความจำทั้งหน้าดังนั้นขนาดที่เล็กที่สุดที่เธรดสามารถเป็นขนาดที่เล็กที่สุดของหน้า มันใหญ่เกินไปจริงๆ

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

ฉันคิดว่ามันเป็นคำตอบถ้าไม่ใช่ทั้งหมดคำถามของฉันอย่างน้อย

ฉันใช้งาน coroutines ในแอสเซมเบลอร์และประสิทธิภาพที่วัดได้

การสลับระหว่าง coroutines หรือที่เรียกว่ากระบวนการ Erlang ใช้เวลาประมาณ 16 คำสั่งและ 20 นาโนวินาทีบนโปรเซสเซอร์ที่ทันสมัย นอกจากนี้คุณมักรู้กระบวนการที่คุณกำลังเปลี่ยนไป (ตัวอย่าง: กระบวนการที่ได้รับข้อความในคิวสามารถดำเนินการได้โดยตรงจากกระบวนการเรียกไปสู่กระบวนการรับ) ดังนั้นตัวกำหนดตารางเวลาจะไม่เข้ามาเล่นทำให้ มันเป็นการดำเนินการ O (1)

ในการสลับเธรด OS จะใช้เวลาประมาณ 500-1,000 นาโนวินาทีเนื่องจากคุณกำลังเรียกใช้เคอร์เนล ตัวกำหนดตารางเวลาเธรด OS อาจทำงานในเวลา O (log (n)) หรือ O (log (log (n))) เวลาซึ่งจะเริ่มสังเกตเห็นได้ถ้าคุณมีหลายหมื่นหรือหลายล้านเธรด

ดังนั้นกระบวนการของ Erlang นั้นเร็วกว่าและปรับขนาดได้ดีกว่าเพราะทั้งการดำเนินการพื้นฐานของการสลับนั้นเร็วกว่า

กระบวนการ Erlang สอดคล้อง (โดยประมาณ) กับเธรดสีเขียวในภาษาอื่น ไม่มีการแยก OS ที่บังคับใช้ระหว่างกระบวนการ (อาจมีการแยกภาษาบังคับ แต่ก็มีการป้องกันที่น้อยกว่าแม้ว่า Erlang จะทำงานได้ดีกว่ามากที่สุด) เนื่องจากมันมีน้ำหนักเบากว่ามากจึงสามารถใช้งานได้กว้างขวางกว่า

ในทางกลับกันระบบปฏิบัติการเธรดสามารถกำหนดเวลาในคอร์ CPU ที่แตกต่างกันได้และ (ส่วนใหญ่) สามารถรองรับการประมวลผลที่ผูกกับ CPU ได้อย่างอิสระ กระบวนการของ OS นั้นเหมือนกับเธรด OS แต่มีการแยกที่บังคับใช้กับ OS ที่แข็งแกร่งกว่ามาก ราคาของความสามารถเหล่านี้คือเธรด OS และ (ยิ่งกว่านั้น) กระบวนการมีราคาแพงกว่า

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

ในหลาย ๆ ทางปัญหาที่แท้จริงคือหนึ่งในคำศัพท์ สิ่งที่ Erlang เรียกกระบวนการ (และสอดคล้องอย่างยิ่งกับแนวคิดเดียวกันใน CSP, CCS และโดยเฉพาะอย่างยิ่ง calcul-แคลคูลัส) นั้นไม่เหมือนกับสิ่งที่ภาษาที่มีมรดกทางวัฒนธรรม C (รวมถึง C ++, Java, C # และ อื่น ๆ อีกมากมาย) เรียกกระบวนการหรือเธรด มีความคล้ายคลึงกันบางอย่าง (ทั้งหมดเกี่ยวข้องกับแนวคิดเรื่องการดำเนินการพร้อมกัน) แต่ไม่มีความเท่าเทียมกันแน่นอน ดังนั้นระวังเมื่อมีคนพูดว่า "กระบวนการ" กับคุณ พวกเขาอาจเข้าใจว่าหมายถึงสิ่งที่แตกต่างอย่างสิ้นเชิง ...

ฉันคิดว่า Jonas ต้องการตัวเลขจำนวนหนึ่งในการเปรียบเทียบเธรด OS กับกระบวนการ Erlang ผู้เขียนโปรแกรม Erlang โจ Armstrong กลับมาทดสอบความยืดหยุ่นของการวางไข่ของกระบวนการ Erlang กับเธรด OS เขาเขียนเว็บเซิร์ฟเวอร์อย่างง่ายใน Erlang และทดสอบกับ Apache แบบมัลติเธรด (ตั้งแต่ Apache ใช้เธรด OS) มีเว็บไซต์เก่าที่มีข้อมูลย้อนหลังไปถึงปี 1998 ฉันจัดการเพื่อค้นหาเว็บไซต์นั้นเพียงครั้งเดียวเท่านั้น ดังนั้นฉันจึงไม่สามารถให้ลิงค์ แต่ข้อมูลก็อยู่ตรงนั้น ประเด็นหลักของการศึกษาแสดงให้เห็นว่า Apache ขยายสูงสุดภายใต้กระบวนการ 8K ในขณะที่เซิร์ฟเวอร์ Erlang ที่เขียนด้วยมือของเขาจัดการกระบวนการ 10K +

เนื่องจากล่าม Erlang เพียง แต่ต้องกังวลเกี่ยวกับตัวเองระบบปฏิบัติการจึงมีสิ่งอื่น ๆ อีกมากมายที่ต้องกังวล

หนึ่งในเหตุผลคือกระบวนการ erlang ไม่ได้สร้างขึ้นในระบบปฏิบัติการ แต่อยู่ใน evm (เครื่องเสมือน erlang) ดังนั้นค่าใช้จ่ายจึงน้อยลง