ทำไมทีมที่ LMAX ใช้จาวาและออกแบบสถาปัตยกรรมเพื่อหลีกเลี่ยง GC ในทุกกรณี?

ทำไมทีมที่ LMAX จึงออกแบบLMAX Disruptorใน Java แต่ทุกจุดของการออกแบบเพื่อลดการใช้งาน GC หากไม่มีใครต้องการให้ GC ทำงานแล้วทำไมต้องใช้ภาษาที่รวบรวมขยะ?

การเพิ่มประสิทธิภาพระดับความรู้ด้านฮาร์ดแวร์และความคิดของพวกเขานั้นยอดเยี่ยม แต่ทำไม Java

ฉันไม่ได้ต่อต้าน Java หรืออะไร แต่ทำไมเป็นภาษา GC ทำไมไม่ใช้สิ่งที่ต้องการ D หรือภาษาอื่นที่ไม่มี GC แต่ให้โค้ดที่มีประสิทธิภาพ? เป็นทีมที่คุ้นเคยกับ Java มากที่สุดหรือ Java นั้นมีข้อได้เปรียบที่ไม่เหมือนใครหรือไม่?

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

เนื่องจากมีความแตกต่างอย่างมากระหว่างการเพิ่มประสิทธิภาพและปิดความปลอดภัยอย่างสมบูรณ์

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

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

เมื่อคุณปรับแต่งประสิทธิภาพคุณมักจะปรับ "ฮอตสปอต" ที่เฉพาะเจาะจงบางอย่างในขณะที่ไม่สนใจรหัสที่ทำงานไม่บ่อย หากคุณทำเช่นนั้นใน Java คุณสามารถปล่อยให้ตัวรวบรวมขยะยังคงดูแลมุมมืดเหล่านั้น (เนื่องจากมันจะไม่สร้างความแตกต่างมากนัก) ในขณะที่ปรับให้เหมาะสมที่สุดสำหรับพื้นที่ที่ทำงานในวงแคบ ดังนั้นคุณสามารถเลือกตำแหน่งที่คุณปรับและไม่ใช้และคุณสามารถมุ่งเน้นความพยายามของคุณในที่ที่มันสำคัญ

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

แต่มันแย่ลงไปอีก

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

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

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

มีค่าใช้จ่ายในการปิดความปลอดภัย การเป็นเจ้าของภาษาไม่สมเหตุสมผลเสมอไป บางครั้งมันง่ายกว่าและปลอดภัยกว่าที่จะเพิ่มประสิทธิภาพของภาษาที่ปลอดภัยเพียงเล็กน้อยเพื่อให้ได้ภาษาที่คุณสามารถยิงด้วยตัวคุณเองในเวลาที่ยิ่งใหญ่ ความถูกต้องและความปลอดภัยในกรณีที่กล้าหาญจำนวนมากไม่กี่วินาทีนาโนที่คุณจะได้ทิ้งโดยการกำจัด GC อย่างสมบูรณ์ Disruptor สามารถใช้ในสถานการณ์เหล่านั้นได้ดังนั้นฉันคิดว่า LMAX-Exchange โทรออกอย่างถูกต้อง

แต่แล้ว D โดยเฉพาะเกี่ยวกับอะไร? คุณมี GC หากคุณต้องการมุมมืดและชุดย่อย SafeD (ที่ฉันไม่ทราบมาก่อนการแก้ไข) ลบพฤติกรรมที่ไม่ได้กำหนด (ถ้าคุณจำได้ว่าจะใช้มัน!)

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

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

ดูเหมือนเหตุผลที่เขียนใน Java คือพวกเขามีความเชี่ยวชาญ Java ในบ้านและมันอาจจะเขียน (แม้ว่าจะยังอยู่ในการพัฒนาที่ใช้งานอยู่) ก่อน C ++ ได้กระทำร่วมกับ C ++ 0x / 11

รหัสของพวกเขาคือ Java จริงๆโดยใช้ชื่อพวกเขาใช้ sun.misc.Unsafe ไม่กี่ชนิดที่เอาชนะจุดของ Java และความปลอดภัยที่ควรจะให้ ฉันได้เขียนพอร์ต C ++ ของ Disruptor และมันมีประสิทธิภาพสูงกว่าโค้ด Java ที่พวกเขาจัดส่ง (ฉันไม่ได้ใช้เวลาปรับจูน JVM มาก)

ที่กล่าวว่าหลักการที่ผู้ทำลายระบบดังต่อไปนี้ไม่ใช่ภาษาที่เฉพาะเจาะจงเช่นอย่าคาดหวังว่ารหัส C ++ แฝงต่ำที่ allocs หรือปลดปล่อยจากฮีป

คำถามนี้ระบุหลักฐานที่ไม่ถูกต้องตามความเป็นจริงแล้วทำให้มีการโต้แย้งเกี่ยวกับหลักฐานที่ไม่ถูกต้องนั้น

ให้ขุดลงไปนี้ .. "จุดการออกแบบทั้งหมดเพื่อลดการใช้งาน GC" - ไม่จริง นวัตกรรมในตัวทำลายมีส่วนเกี่ยวข้องกับ GC เพียงเล็กน้อย ตัวขัดขวางทำงานได้เนื่องจากการออกแบบได้พิจารณาอย่างชาญฉลาดว่าคอมพิวเตอร์สมัยใหม่ทำงานอย่างไร - บางสิ่งที่พบได้น้อยกว่าที่คาดไว้มาก ดูการพูดคุยของคลิฟคลิกhttp://www.azulsystems.com/events/javaone_2009/session/2009_J1_HardwareCrashCourse.pdfสำหรับการสนทนา

มันเป็นที่รู้จักกันดีว่า LMax เป็นลูกค้าของ Azul ฉันรู้โดยตรงว่าด้วย Azul GCs นั้นไม่ใช่แบบธรรมดา - แม้จะมีขนาด 175GB

พวกเขาจะต้องคิดในระดับต่ำ

ด้านบนทำให้คำตอบครึ่งหนึ่งที่คุณต้องการ คุณสามารถหาเหตุผลอีกครึ่งหนึ่งให้เสร็จสมบูรณ์โดยไม่มีเหตุผลมากไปกว่าในบล็อก LMAX :

ในขณะที่มีประสิทธิภาพมากมันสามารถนำไปสู่ข้อผิดพลาดได้หลายอย่างเนื่องจากง่ายต่อการผิดพลาด ...

เป็นที่ยอมรับโดยนักพัฒนา LMAX รหัสเช่นนั้นอาจค่อนข้างยากที่จะพัฒนาทำความเข้าใจและแก้ไขปัญหา - แม้ใน Java การก้าวไปสู่ระดับที่ต่ำกว่าที่ตอนนี้จะทำให้ปัญหานี้รุนแรงขึ้นดังที่ได้กล่าวไว้ในบทความ Wikipedia เกี่ยวกับภาษาการเขียนโปรแกรมระดับต่ำ :

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

โดยการเปรียบเทียบภาษาการเขียนโปรแกรมระดับสูงจะแยกซีแมนติกการประมวลผลของสถาปัตยกรรมคอมพิวเตอร์ออกจากข้อกำหนดของโปรแกรมซึ่งทำให้การพัฒนาง่ายขึ้น ...

หากคุณใช้ Java เป็นภาษาไวยากรณ์และหลีกเลี่ยงไลบรารี JDK มันจะเร็วเท่ากับภาษาที่ไม่ใช่ GC ที่คอมไพล์ GC ไม่เหมาะสำหรับระบบเรียลไทม์ แต่เป็นไปได้ที่จะพัฒนาระบบใน Java ที่ไม่ทิ้งขยะใด ๆ ไว้ข้างหลัง ด้วยเหตุนี้ GC จึงไม่เรียกใช้

เราเชื่อว่าภาษาจาวาและแพลตฟอร์มมีข้อได้เปรียบเหนือ C / C ++ และเราได้พัฒนาและเปรียบเทียบส่วนประกอบของ Java ที่มีความหน่วงต่ำพิเศษเพื่อพิสูจน์มัน เราพูดคุยเกี่ยวกับเทคนิคในการทำเช่นนั้นในบทความนี้: การพัฒนา Java โดยไม่ต้อง GC

LMAX เป็นห้องสมุดส่งข้อความระหว่างเธรดประสิทธิภาพสูง

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

การใช้ C หรือ C ++ นั้นไม่ใช่ตัวเลือกที่ดียกเว้นว่าคุณต้องการ จำกัด ผู้ใช้ของคุณให้อยู่ในระบบปฏิบัติการเดียวเนื่องจากไม่มีรูปแบบเธรดที่กำหนดไว้ในนั้น

Java เป็นมาตรฐานสำหรับการพัฒนาซอฟต์แวร์จำนวนมากในทุกวันนี้ดังนั้นหากคุณไม่มีเหตุผลที่ดีไม่เช่นนั้นก็มีแนวโน้มที่จะเป็นทางเลือกที่ดีที่สุด (เมื่ออยู่ในกรุงโรมทำในฐานะชาวโรมัน…)

การเขียนซอฟต์แวร์ประสิทธิภาพสูงใน Java (หรือ C #) มักจะทำเพื่อพิสูจน์จุด ...