คำถามติดแท็ก garbage-collection

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

26 functional-programming  language-agnostic  garbage-collection 

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

24 java  architecture  performance  garbage-collection  d 

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

24 low-level  garbage-collection 

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

23 memory  garbage-collection 

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

18 garbage-collection 

ตัวรวบรวมขยะ (อย่างน้อย Mono's และ. NET) บางตัวมีพื้นที่หน่วยความจำระยะสั้นซึ่งสแกนบ่อยและพื้นที่หน่วยความจำรองที่สแกนน้อยกว่า โมโนเรียกสถานเลี้ยงเด็กแห่งนี้ เพื่อค้นหาว่าวัตถุใดที่สามารถกำจัดได้พวกมันจะสแกนวัตถุทั้งหมดที่เริ่มต้นจากรากสแต็คและรีจิสเตอร์และกำจัดวัตถุทั้งหมดที่ไม่ได้ถูกอ้างอิงอีกต่อไป คำถามของฉันคือพวกเขาป้องกันไม่ให้หน่วยความจำที่ใช้งานทั้งหมดถูกสแกนในการรวบรวมทุกครั้งหรือไม่ โดยหลักการแล้ววิธีเดียวที่จะค้นหาว่าวัตถุใดไม่ได้ใช้งานอีกต่อไปคือการสแกนวัตถุทั้งหมดและการอ้างอิงทั้งหมด อย่างไรก็ตามนี่จะเป็นการป้องกันไม่ให้ระบบปฏิบัติการแลกเปลี่ยนหน่วยความจำแม้ว่าแอปพลิเคชั่นจะไม่ได้ใช้งานและรู้สึกว่าเป็นงานที่ต้องทำจำนวนมากเช่นกันสำหรับ "Nursery Collection" ไม่รู้สึกว่าพวกเขาชนะมากจากการใช้เรือนเพาะชำ ฉันทำบางสิ่งบางอย่างหายไปหรือว่าตัวรวบรวมขยะกำลังสแกนวัตถุทั้งหมดและทุกการอ้างอิงทุกครั้งที่มีการรวบรวมหรือไม่

16 algorithms  garbage-collection 

จำเป็นต้องมีการเก็บรวบรวมขยะ (GC) ในภาษาที่ใช้สแต็กคืออะไร? ในภาษาอย่างForthหรือRPL (บนเครื่องคิดเลขของ HP ) จำเป็นต้องมีการรวบรวมขยะหรือไม่? ฉันคิดว่าเนื่องจากเอาต์พุตถูกสแต็กออกจากสแต็กดังนั้นจึงไม่มีความจำเป็นใด ๆ ฉันพลาดอะไรไปรึเปล่า?

16 garbage-collection  stack-oriented 

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

13 algorithms  garbage-collection 

ฉันได้รับ / dev / random เป็นแหล่งข้อมูลที่ดีของเอนโทรปีและเป็นสิ่งที่ใช้กันทั่วไป - มันก็เหมือนกับที่ฉันอ่านบน GC อย่างน้อยใน Java ดูเหมือนว่าเป็นที่ยอมรับว่า daemon การรวบรวมขยะเรียกใช้งานแบบไม่กำหนดค่า . ถ้าเป็นจริงทำไมเราไม่ใช้เวลาของการรวบรวมขยะเป็นแหล่งของเอนโทรปีแทนที่จะเป็นตัวแปร / dev / random?

13 random  garbage-collection 

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

12 algorithms  low-level  garbage-collection 

Java และ. NET มีตัวรวบรวมขยะที่ยอดเยี่ยมที่จัดการหน่วยความจำสำหรับคุณและรูปแบบที่สะดวกสำหรับการปล่อยวัตถุภายนอก ( Closeable, IDisposable) ได้อย่างรวดเร็วแต่เฉพาะในกรณีที่พวกเขาเป็นเจ้าของวัตถุเดียว ในบางระบบทรัพยากรอาจจำเป็นต้องใช้อย่างอิสระโดยสององค์ประกอบและจะได้รับการปล่อยตัวก็ต่อเมื่อทั้งสององค์ประกอบปล่อยทรัพยากร ใน C ++ ยุคใหม่คุณจะแก้ปัญหานี้ด้วย a shared_ptrซึ่งจะปล่อยทรัพยากรอย่างแน่นอนเมื่อทุกอย่างshared_ptrถูกทำลาย มีรูปแบบเอกสารที่ผ่านการพิสูจน์แล้วสำหรับการจัดการและปล่อยทรัพยากรที่มีราคาแพงซึ่งไม่มีเจ้าของคนเดียวในระบบที่รวบรวมขยะแบบไม่มุ่งเน้นวัตถุหรือไม่?

11 java  c#  design-patterns  garbage-collection  reference-counting 

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

11 java  interview  garbage-collection 

ทั้ง Windows Phone / Xbox และ Android ขาดการสนับสนุนสำหรับการรวบรวมขยะทั่วไป นี่น่าผิดหวังสำหรับโปรแกรมเมอร์จำนวนมาก ดูเหมือนจะมีเหตุผลทางวิศวกรรมที่ถูกต้องตามกฎหมาย แต่ฉันไม่สามารถเข้าใจได้ โทรศัพท์ปัจจุบันมีหน่วยความจำเพิ่มขึ้นและอาจมี CPU ที่ดีกว่าเดสก์ท็อป / แล็ปท็อปที่ใช้. NET 1.1 กับ generational GC ย้อนกลับไปในปี 2544 และฉันไม่สามารถคิดได้ว่าเหตุผลใดที่โปรเซสเซอร์ ARM จะแย่กว่ารุ่นทั่วไป นอกจากนี้ยังมีความต้องการน้อยลงสำหรับการทำมัลติทาสก์บนโทรศัพท์และคอนโซลดังนั้นจึงมีพื้นที่ว่างมากขึ้น แล้วอะไรล่ะ แก้ไข:สองสามจุดเพื่อชี้แจง: แพลตฟอร์มเหล่านี้ใช้การรวบรวมขยะสำหรับแอปโดยเฉพาะดังนั้นคำถามของฉันไม่เกี่ยวกับสาเหตุที่ GC ไม่รองรับ คำถามของฉันเกี่ยวกับสาเหตุที่generationalเก็บขยะไม่ได้ เหตุผลที่ผู้คนรู้สึกหงุดหงิดเกี่ยวกับการขาด GC generational นั่นคือ GC ที่ไม่ใช่เชิงพันธุกรรมนั้นไม่มีประสิทธิภาพอย่างมาก (นั่นหมายความว่าอายุการใช้งานแบตเตอรี่ไม่ใช่เหตุผล) ฉันเชื่อว่ามีเหตุผลทางเทคนิคที่ซื่อสัตย์สำหรับการขาดการสนับสนุน GC generational นี่ไม่ใช่คำถามเชิงโวหาร

11 java  .net  android  windows-phone-7  garbage-collection 

จากสิ่งที่ฉันเห็นมีรูปแบบการจัดการทรัพยากรที่แพร่หลายอยู่สองรูปแบบคือการทำลายล้างที่กำหนดขึ้นและชัดเจน ตัวอย่างของอดีตจะเป็น destructors C ++ และตัวชี้สมาร์ทหรือย่อย DESTROY ของ Perl ในขณะที่ตัวอย่างหลังจะเป็นกระบวนทัศน์แบบบล็อกต่อการจัดการทรัพยากรของ Ruby หรืออินเทอร์เฟซ IDispose ของ. NET ภาษาที่ใหม่กว่าดูเหมือนจะเลือกใช้ในภายหลังซึ่งอาจเป็นผลข้างเคียงของการใช้ระบบรวบรวมขยะที่หลากหลายที่ไม่อ้างอิงการนับ คำถามของฉันคือ: เนื่องจาก destructors สำหรับสมาร์ทพอยน์เตอร์หรือระบบรวบรวมขยะอ้างอิง - เกือบจะเป็นสิ่งเดียวกัน - อนุญาตให้มีการทำลายทรัพยากรโดยปริยายและโปร่งใสมันเป็นสิ่งที่เป็นนามธรรมน้อยรั่วกว่าประเภทที่ไม่ได้กำหนดไว้ล่วงหน้า สัญกรณ์? ฉันจะยกตัวอย่างที่เป็นรูปธรรม หากคุณมีคลาสย่อย C ++ สามคลาสของซูเปอร์คลาสเดียวอาจมีการใช้งานที่ไม่ต้องการการทำลายที่เฉพาะเจาะจง บางทีมันอาจใช้เวทมนตร์ในอีกทางหนึ่ง ความจริงที่ว่ามันไม่ต้องการการทำลายพิเศษใด ๆ นั้นไม่เกี่ยวข้อง - คลาสย่อยทั้งหมดยังคงใช้ในลักษณะเดียวกัน ตัวอย่างอื่นใช้บล็อก Ruby คลาสย่อยสองคลาสจำเป็นต้องเพิ่มรีซอร์สดังนั้นคลาสคลาส opts สำหรับอินเตอร์เฟสที่ใช้บล็อกในตัวสร้างแม้ว่าคลาสย่อยย่อยอื่นอาจไม่ต้องการเนื่องจากมันไม่ต้องการการทำลายพิเศษ เป็นกรณีที่การรั่วไหลหลังรายละเอียดการใช้งานของการทำลายทรัพยากรในขณะที่อดีตไม่ได้หรือไม่ แก้ไข: การเปรียบเทียบสมมติว่า Ruby กับ Perl อาจมีความยุติธรรมมากกว่าเนื่องจากมีการทำลายล้างที่กำหนดและที่เหลือไม่ได้ แต่พวกเขาทั้งคู่เก็บขยะ

9 c++  ruby  perl  garbage-collection  smart-pointer 

สมมติว่ามีสองเธรดซึ่งสื่อสารโดยการส่งข้อความข้อมูลแบบอะซิงโครนัสซึ่งกันและกัน แต่ละเธรดมีคิวข้อความบางประเภท คำถามของฉันอยู่ในระดับต่ำมาก: สิ่งที่คาดว่าจะเป็นวิธีที่มีประสิทธิภาพที่สุดในการจัดการหน่วยความจำ? ฉันสามารถคิดถึงวิธีแก้ปัญหาต่าง ๆ : newผู้ส่งสร้างวัตถุผ่าน deleteโทรผู้รับ Memory pooling (เพื่อโอนหน่วยความจำกลับไปยังผู้ส่ง) การรวบรวมขยะ (เช่น Boehm GC) (ถ้าวัตถุมีขนาดเล็กพอ) คัดลอกตามค่าเพื่อหลีกเลี่ยงการจัดสรรฮีปอย่างสมบูรณ์ 1) เป็นคำตอบที่ชัดเจนที่สุดดังนั้นฉันจะใช้มันสำหรับต้นแบบ มีโอกาสที่มันจะดีอยู่แล้ว แต่เป็นอิสระจากปัญหาเฉพาะของฉันฉันสงสัยว่าเทคนิคใดมีแนวโน้มมากที่สุดหากคุณกำลังปรับประสิทธิภาพการทำงานให้ดีที่สุด ฉันคาดหวังว่าการรวมกันจะดีที่สุดในทางทฤษฎีโดยเฉพาะอย่างยิ่งเพราะคุณสามารถใช้ความรู้เพิ่มเติมเกี่ยวกับการไหลของข้อมูลระหว่างเธรด อย่างไรก็ตามฉันกลัวว่ามันเป็นการยากที่จะทำถูกที่สุด การปรับแต่งมากมาย ... :-( การรวบรวมขยะควรเพิ่มได้อย่างง่ายดายหลังจากนั้น (หลังจากโซลูชันที่ 1) และฉันคาดว่ามันจะทำงานได้ดีมาก ดังนั้นฉันคิดว่ามันเป็นวิธีแก้ปัญหาที่ใช้งานได้จริงหาก 1) กลายเป็นว่าไม่มีประสิทธิภาพเกินไป หากวัตถุมีขนาดเล็กและเรียบง่ายการคัดลอกตามค่าอาจเร็วที่สุด อย่างไรก็ตามฉันกลัวว่ามันจะบังคับให้มีข้อ จำกัด ที่ไม่จำเป็นในการใช้งานข้อความที่รองรับดังนั้นฉันจึงต้องการหลีกเลี่ยง

9 c++  performance  low-level  garbage-collection