แนวทางปฏิบัติที่ดีที่สุดในการลดกิจกรรม Garbage Collector ใน Javascript

ฉันมีแอป Javascript ที่ค่อนข้างซับซ้อนซึ่งมีลูปหลักที่เรียกว่า 60 ครั้งต่อวินาที ดูเหมือนว่าจะมีการรวบรวมขยะจำนวนมากเกิดขึ้น (ตามเอาต์พุต 'ฟันเลื่อย' จากไทม์ไลน์หน่วยความจำในเครื่องมือ Chrome dev) - และสิ่งนี้มักส่งผลกระทบต่อประสิทธิภาพของแอปพลิเคชัน

ดังนั้นฉันจึงพยายามค้นคว้าแนวทางปฏิบัติที่ดีที่สุดในการลดปริมาณงานที่พนักงานเก็บขยะต้องทำ (ข้อมูลส่วนใหญ่ที่ฉันสามารถหาได้บนเว็บเกี่ยวกับการหลีกเลี่ยงการรั่วไหลของหน่วยความจำซึ่งเป็นคำถามที่แตกต่างกันเล็กน้อย - หน่วยความจำของฉันได้รับการปลดปล่อยเพียงแค่มีการรวบรวมขยะมากเกินไป) ฉันสมมติว่า สิ่งนี้ส่วนใหญ่มาจากการนำวัตถุกลับมาใช้ใหม่ให้มากที่สุด แต่แน่นอนว่าปีศาจอยู่ในรายละเอียด

แอปพลิเคมีโครงสร้างใน 'เรียน' ตามสายของจอห์นเรซิกง่าย JavaScript มรดก

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

ฉันตระหนักถึงการรวมกันของวัตถุสำหรับวัตถุที่ใหญ่กว่า / หนักกว่า (และเราใช้สิ่งนี้ในระดับหนึ่ง) แต่ฉันกำลังมองหาเทคนิคที่สามารถนำไปใช้ทั่วกระดานโดยเฉพาะอย่างยิ่งที่เกี่ยวข้องกับฟังก์ชันที่เรียกหลายครั้งในการวนซ้ำที่แน่นหนา .

ฉันสามารถใช้เทคนิคอะไรเพื่อลดปริมาณงานที่พนักงานเก็บขยะต้องทำ?

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

หลายสิ่งที่คุณต้องทำเพื่อลด GC churn ให้น้อยที่สุดให้เทียบกับสิ่งที่ถือว่าเป็นสำนวน JS ในสถานการณ์อื่น ๆ ส่วนใหญ่ดังนั้นโปรดคำนึงถึงบริบทเมื่อตัดสินคำแนะนำที่ฉันให้

การจัดสรรเกิดขึ้นในล่ามสมัยใหม่ในหลาย ๆ ที่:

1. เมื่อคุณสร้างออบเจ็กต์ผ่านnewหรือผ่านทางไวยากรณ์ตามตัวอักษร[...]หรือ{}.
2. เมื่อคุณเชื่อมสตริงเข้าด้วยกัน
3. เมื่อคุณป้อนขอบเขตที่มีการประกาศฟังก์ชัน
4. เมื่อคุณดำเนินการที่ทำให้เกิดข้อยกเว้น
5. เมื่อคุณประเมินนิพจน์ฟังก์ชัน: (function (...) { ... }).
6. เมื่อคุณดำเนินการที่บังคับให้ Object เหมือนObject(myNumber)หรือNumber.prototype.toString.call(42)
7. เมื่อคุณเรียกบิวอินที่ทำสิ่งเหล่านี้ภายใต้ประทุนเช่นArray.prototype.slice.
8. เมื่อคุณใช้argumentsเพื่อสะท้อนรายการพารามิเตอร์
9. เมื่อคุณแยกสตริงหรือจับคู่กับนิพจน์ทั่วไป

หลีกเลี่ยงการทำสิ่งเหล่านั้นและรวมและนำวัตถุกลับมาใช้ใหม่หากเป็นไปได้

โดยเฉพาะอย่างยิ่งมองหาโอกาสที่จะ:

1. ดึงฟังก์ชั่นภายในที่ไม่มีการพึ่งพาหรือไม่กี่อย่างในสถานะปิดออกไปสู่ขอบเขตที่สูงขึ้นและมีอายุการใช้งานยาวนานขึ้น (ตัวย่อโค้ดบางตัวเช่นคอมไพเลอร์ปิดสามารถอินไลน์ฟังก์ชันภายในและอาจปรับปรุงประสิทธิภาพ GC ของคุณ)
2. หลีกเลี่ยงการใช้สตริงเพื่อแสดงข้อมูลที่มีโครงสร้างหรือสำหรับการกำหนดแอดเดรสแบบไดนามิก โดยเฉพาะอย่างยิ่งหลีกเลี่ยงการแยกวิเคราะห์ซ้ำ ๆ โดยใช้splitหรือการจับคู่นิพจน์ทั่วไปเนื่องจากแต่ละรายการต้องมีการจัดสรรวัตถุหลายรายการ สิ่งนี้มักเกิดขึ้นกับคีย์ในตารางการค้นหาและ ID โหนด DOM แบบไดนามิก ตัวอย่างเช่นlookupTable['foo-' + x]และdocument.getElementById('foo-' + x)ทั้งสองเกี่ยวข้องกับการจัดสรรเนื่องจากมีการต่อสายอักขระ บ่อยครั้งที่คุณสามารถแนบกุญแจกับวัตถุที่มีอายุยืนยาวแทนที่จะเชื่อมต่อกันใหม่ คุณอาจสามารถMapใช้ออบเจ็กต์เป็นคีย์ได้โดยตรงทั้งนี้ขึ้นอยู่กับเบราว์เซอร์ที่คุณต้องการรองรับ
3. หลีกเลี่ยงการจับข้อยกเว้นบนเส้นทางรหัสปกติ แทนการทำtry { op(x) } catch (e) { ... }if (!opCouldFailOn(x)) { op(x); } else { ... }
4. เมื่อคุณไม่สามารถหลีกเลี่ยงการสร้างสตริงเช่นเพื่อส่งข้อความไปยังเซิร์ฟเวอร์ให้ใช้บิวอินJSON.stringifyที่ใช้บัฟเฟอร์เนทีฟภายในเพื่อสะสมเนื้อหาแทนที่จะจัดสรรอ็อบเจ็กต์หลายตัว
5. หลีกเลี่ยงการใช้การโทรกลับสำหรับเหตุการณ์ที่มีความถี่สูงและในกรณีที่คุณสามารถส่งผ่านเป็นฟังก์ชันที่มีอายุการใช้งานยาวนาน (ดู 1) ที่สร้างสถานะขึ้นมาใหม่จากเนื้อหาข้อความ
6. หลีกเลี่ยงการใช้argumentsตั้งแต่ฟังก์ชันที่ใช้ที่ต้องสร้างวัตถุคล้ายอาร์เรย์เมื่อถูกเรียก

ฉันแนะนำให้ใช้JSON.stringifyเพื่อสร้างข้อความเครือข่ายขาออก การแยกวิเคราะห์ข้อความที่ป้อนโดยใช้JSON.parseชัดเจนเกี่ยวข้องกับการจัดสรรและจำนวนมากสำหรับข้อความขนาดใหญ่ หากคุณสามารถแสดงข้อความขาเข้าของคุณเป็นอาร์เรย์ของแบบดั้งเดิมคุณจะสามารถบันทึกการจัดสรรได้มาก builtin เฉพาะอื่น ๆ String.prototype.charCodeAtที่คุณสามารถสร้างแยกวิเคราะห์ที่ไม่ได้จัดสรรเป็น ตัวแยกวิเคราะห์สำหรับรูปแบบที่ซับซ้อนซึ่งใช้เฉพาะที่จะอ่านได้อย่างชั่วร้าย

Chrome เครื่องมือสำหรับนักพัฒนามีคุณลักษณะที่ดีมากสำหรับการติดตามการจัดสรรหน่วยความจำ เรียกว่า Memory Timeline บทความนี้อธิบายรายละเอียดบางประการ ฉันคิดว่านี่คือสิ่งที่คุณกำลังพูดถึง "ฟันเลื่อย"? นี่เป็นพฤติกรรมปกติสำหรับรันไทม์ส่วนใหญ่ของ GC การจัดสรรจะดำเนินไปจนกว่าจะถึงเกณฑ์การใช้งานที่เรียกใช้คอลเลกชัน โดยปกติจะมีคอลเล็กชันหลายประเภทในเกณฑ์ที่ต่างกัน

คอลเลกชันขยะจะรวมอยู่ในรายการเหตุการณ์ที่เกี่ยวข้องกับการติดตามพร้อมกับระยะเวลา ในสมุดบันทึกที่ค่อนข้างเก่าของฉันคอลเลกชันชั่วคราวจะเกิดขึ้นที่ประมาณ 4Mb และใช้เวลา 30ms นี่คือ 2 ของการวนซ้ำ 60Hz ของคุณ หากเป็นภาพเคลื่อนไหวคอลเลกชั่น 30ms อาจทำให้พูดติดอ่าง คุณควรเริ่มต้นที่นี่เพื่อดูว่าเกิดอะไรขึ้นในสภาพแวดล้อมของคุณ: เกณฑ์การเก็บรวบรวมอยู่ที่ใดและการเก็บรวบรวมของคุณใช้เวลานานเท่าใด สิ่งนี้ทำให้คุณมีจุดอ้างอิงในการประเมินการเพิ่มประสิทธิภาพ แต่คุณอาจทำได้ไม่ดีไปกว่าการลดความถี่ของการพูดติดอ่างโดยการทำให้อัตราการจัดสรรช้าลงทำให้ช่วงเวลาระหว่างคอลเลกชันยาวขึ้น

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

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

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

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

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

var options = {var1: value1, var2: value2, ChangingVariable: value3};
function loopfunc()
{
    //do something
}

while(true)
{
    $.each(listofthings, loopfunc);

    options.ChangingVariable = newvalue;
    someOtherFunction(options);
}

จะทำงานได้เร็วกว่านี้มาก:

while(true)
{
    $.each(listofthings, function(){
        //do something on the list
    });

    someOtherFunction({
        var1: value1,
        var2: value2,
        ChangingVariable: newvalue
    });
}

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

ขออภัยหากทั้งหมดนี้เป็นเรื่องเล็กน้อยเมื่อเทียบกับสิ่งที่คุณได้ลองและคิดไว้แล้ว

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

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

ปล. มันอาจทำให้โค้ดบางส่วนนั้นดูแลรักษาได้น้อยลงเล็กน้อย