Understanding Automatic Memory Mana

Understanding Automatic Memory Management
When an object, string or array is created, the memory required to store it is allocated from a central pool called the heap. When the item is no longer in use, the memory it once occupied can be reclaimed and used for something else. In the past, it was typically up to the programmer to allocate and release these blocks of heap memory explicitly with the appropriate function calls. Nowadays, runtime systems like Unity’s Mono engine manage memory for you automatically. Automatic memory management requires less coding effort than explicit allocation/release and greatly reduces the potential for memory leakage (the situation where memory is allocated but never subsequently released).

Value and Reference Types

When a function is called, the values of its parameters are copied to an area of memory reserved for that specific call. Data types that occupy only a few bytes can be copied very quickly and easily. However, it is common for objects, strings and arrays to be much larger and it would be very inefficient if these types of data were copied on a regular basis. Fortunately, this is not necessary; the actual storage space for a large item is allocated from the heap and a small “pointer” value is used to remember its location. From then on, only the pointer need be copied during parameter passing. As long as the runtime system can locate the item identified by the pointer, a single copy of the data can be used as often as necessary.

Types that are stored directly and copied during parameter passing are called value types. These include integers, floats, booleans and Unity’s struct types (eg, Color and Vector3). Types that are allocated on the heap and then accessed via a pointer are called reference types, since the value stored in the variable merely “refers” to the real data. Examples of reference types include objects, strings and arrays.

Allocation and Garbage Collection

The memory manager keeps track of areas in the heap that it knows to be unused. When a new block of memory is requested (say when an object is instantiated), the manager chooses an unused area from which to allocate the block and then removes the allocated memory from the known unused space. Subsequent requests are handled the same way until there is no free area large enough to allocate the required block size. It is highly unlikely at this point that all the memory allocated from the heap is still in use. A reference item on the heap can only be accessed as long as there are still reference variables that can locate it. If all references to a memory block are gone (ie, the reference variables have been reassigned or they are local variables that are now out of scope) then the memory it occupies can safely be reallocated.

To determine which heap blocks are no longer in use, the memory manager searches through all currently active reference variables and marks the blocks they refer to as “live”. At the end of the search, any space between the live blocks is considered empty by the memory manager and can be used for subsequent allocations. For obvious reasons, the process of locating and freeing up unused memory is known as garbage collection (or GC for short).

Optimization

Garbage collection is automatic and invisible to the programmer but the collection process actually requires significant CPU time behind the scenes. When used correctly, automatic memory management will generally equal or beat manual allocation for overall performance. However, it is important for the programmer to avoid mistakes that will trigger the collector more often than necessary and introduce pauses in execution.

There are some infamous algorithms that can be GC nightmares even though they seem innocent at first sight. Repeated string concatenation is a classic example:

ผลลัพธ์ (ไทย) 1:

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

ผลลัพธ์ (ไทย) 2:

ทำความเข้าใจเกี่ยวกับการบริหารจัดการหน่วยความจำอัตโนมัติ
เมื่อวัตถุสตริงหรืออาร์เรย์จะถูกสร้างขึ้นหน่วยความจำที่จำเป็นต้องใช้ในการจัดเก็บจะมีการจัดสรรจากสระว่ายน้ำกลางที่เรียกว่ากอง เมื่อรายการที่ไม่ได้อยู่ในการใช้งานหน่วยความจำที่มันเคยครอบครองสามารถเรียกคืนและใช้สำหรับการอย่างอื่น ในอดีตที่ผ่านมามันก็มักจะขึ้นอยู่กับโปรแกรมที่จะจัดสรรและปล่อยบล็อกเหล่านี้ของหน่วยความจำกองอย่างชัดเจนกับสายงานที่เหมาะสม ปัจจุบันระบบ Runtime เช่นความสามัคคีของเครื่องยนต์โมโนจัดการหน่วยความจำให้คุณโดยอัตโนมัติ จัดการหน่วยความจำอัตโนมัติต้องใช้ความพยายามน้อยเข้ารหัสกว่าอย่างชัดเจนจัดสรร / ปล่อยและช่วยลดศักยภาพในการรั่วไหลของหน่วยความจำ (สถานการณ์ที่หน่วยความจำจะถูกจัดสรร แต่ไม่เคยได้รับการปล่อยตัวในภายหลัง). มูลค่าและประเภทของการอ้างอิงเมื่อมีฟังก์ชั่นที่เรียกว่าค่าพารามิเตอร์ของมันจะถูกคัดลอก ไปยังพื้นที่ของหน่วยความจำที่สงวนไว้สำหรับการเรียกเฉพาะว่า ชนิดข้อมูลที่ครอบครองเพียงไม่กี่ไบต์สามารถคัดลอกอย่างรวดเร็วและง่ายดาย แต่ก็เป็นเรื่องธรรมดาสำหรับวัตถุสตริงและอาร์เรย์จะมีขนาดใหญ่มากและมันจะไม่มีประสิทธิภาพมากถ้าเหล่านี้ประเภทของข้อมูลที่ถูกคัดลอกเป็นประจำ โชคดีที่นี้ไม่จำเป็น; พื้นที่จัดเก็บที่เกิดขึ้นจริงสำหรับรายการที่มีขนาดใหญ่จะถูกจัดสรรจากกองและมีขนาดเล็ก "ชี้" ค่าใช้ในการจำตำแหน่งของมัน จากนั้นเพียงตัวชี้จำเป็นต้องมีการคัดลอกในช่วงที่ผ่านพารามิเตอร์ ตราบใดที่ระบบรันไทม์สามารถค้นหารายการที่ระบุโดยตัวชี้สำเนาเดียวของข้อมูลที่สามารถนำมาใช้บ่อยเท่าที่จำเป็น. ชนิดที่ถูกเก็บไว้โดยตรงและคัดลอกในช่วงที่ผ่านพารามิเตอร์จะเรียกว่าค่าประเภท เหล่านี้รวมถึงจำนวนเต็มลอย booleans และความสามัคคีของประเภท struct (เช่นสีและ Vector3) ชนิดที่ถูกปันส่วนในกองและเข้าถึงแล้วผ่านตัวชี้จะเรียกว่าประเภทของการอ้างอิงตั้งแต่ค่าที่เก็บไว้ในตัวแปรเพียง "หมายถึง" ข้อมูลจริง ตัวอย่างของประเภทของการอ้างอิงรวมถึงวัตถุสตริงและอาร์เรย์. จัดสรรและการเก็บรวบรวมขยะจัดการหน่วยความจำติดตามพื้นที่ในกองที่มันรู้ที่จะไม่ได้ใช้ เมื่อบล็อกใหม่ของหน่วยความจำที่มีการร้องขอ (พูดเมื่อวัตถุถูก instantiated) ผู้จัดการเลือกพื้นที่ที่ไม่ได้ใช้จากการที่จะจัดสรรบล็อกแล้วเอาจัดสรรหน่วยความจำจากพื้นที่ไม่ได้รู้จักกัน ร้องขอตามมาได้รับการจัดการในลักษณะเดียวกันจนกว่าจะไม่มีพื้นที่ฟรีมีขนาดใหญ่พอที่จะจัดสรรขนาดบล็อกที่จำเป็น มันไม่น่าเป็นอย่างสูงที่จุดนี้ว่าหน่วยความจำทั้งหมดที่จัดสรรจากกองยังคงอยู่ในการใช้งาน รายการอ้างอิงในกองสามารถเข้าถึงได้ตราบใดที่ยังคงมีการอ้างอิงตัวแปรที่สามารถค้นหาได้ หากอ้างอิงถึงบล็อกหน่วยความจำที่หายไป (เช่นตัวแปรอ้างอิงที่ได้รับพระราชเสาวนีย์หรือพวกเขาเป็นตัวแปรท้องถิ่นที่มีตอนนี้ออกจากขอบเขต) แล้วหน่วยความจำหมกมุ่นอยู่กับมันได้อย่างปลอดภัยจะจัดสรร. การตรวจสอบบล็อกกองไม่ได้อยู่ในการใช้งาน ผู้จัดการหน่วยความจำค้นหาผ่านตัวแปรอ้างอิงที่ใช้งานอยู่ทั้งหมดและทำเครื่องหมายบล็อกที่พวกเขาเรียกว่า "ชีวิต" ในตอนท้ายของการค้นหาพื้นที่ใด ๆ ระหว่างบล็อกสดถือว่าเป็นที่ว่างเปล่าโดยการจัดการหน่วยความจำและสามารถนำมาใช้สำหรับการจัดสรรในภายหลัง สำหรับเหตุผลที่ชัดเจนกระบวนการตำแหน่งและพ้นหน่วยความจำที่ไม่ได้ใช้เป็นที่รู้จักกันเก็บขยะ (หรือ GC สั้น ๆ ). การเพิ่มประสิทธิภาพการเก็บขยะเป็นไปโดยอัตโนมัติและมองไม่เห็นโปรแกรมเมอร์ แต่กระบวนการเก็บรวบรวมจริงต้องใช้เวลา CPU อย่างมีนัยสำคัญอยู่เบื้องหลัง เมื่อนำมาใช้อย่างถูกต้องจัดการหน่วยความจำอัตโนมัติโดยทั่วไปจะเท่ากับหรือชนะการจัดสรรคู่มือสำหรับประสิทธิภาพโดยรวม แต่ก็เป็นสิ่งสำคัญสำหรับโปรแกรมเมอร์ที่จะหลีกเลี่ยงความผิดพลาดที่จะเรียกเก็บมักจะเกินกว่าที่จำเป็นและแนะนำการหยุดในการดำเนินการ. มีบางขั้นตอนวิธีการที่น่าอับอายที่สามารถเป็นฝันร้าย GC มีถึงแม้ว่าพวกเขาดูเหมือนบริสุทธิ์ตั้งแต่แรกเห็น ซ้ำแล้วซ้ำอีก concatenation สตริงเป็นตัวอย่างที่คลาสสิก:

ผลลัพธ์ (ไทย) 3:

ความเข้าใจและการจัดการหน่วยความจำโดยอัตโนมัติเมื่อวัตถุสตริงหรืออาเรย์ คือ สร้างความทรงจำที่ต้องเก็บจะได้มาจากสระน้ำกลางที่เรียกว่ากอง . เมื่อรายการไม่ใช้ หน่วยความจำมันเคยครอบครองจะได้กลับคืนมา และใช้สำหรับอะไร ในอดีต มันเป็นโดยทั่วไป ให้โปรแกรมเมอร์ที่จะจัดสรรและปล่อยบล็อกเหล่านี้ความทรงจำกองอย่างชัดเจนกับฟังก์ชันที่เรียก ทุกวันนี้ ทำงานเหมือนกับระบบเอกภาพผ่านเครื่องมือการจัดการหน่วยความจำสำหรับคุณโดยอัตโนมัติ การจัดการหน่วยความจำโดยอัตโนมัติ ต้องใช้ความพยายามมากกว่าน้อยกว่านะครับปล่อยจัดสรร / อย่างชัดเจนและลดศักยภาพสำหรับการรั่วไหลของหน่วยความจำ ( สถานการณ์ที่หน่วยความจำจะถูกจัดสรร แต่ไม่เคยนำออก )ค่าอ้างอิงและประเภทเมื่อฟังก์ชันถูกเรียกค่าของพารามิเตอร์จะถูกคัดลอกไปยังพื้นที่ของหน่วยความจำที่สงวนไว้สำหรับเรียกที่เฉพาะเจาะจง ประเภทข้อมูลที่ใช้เพียงไม่กี่ไบต์จะถูกคัดลอกอย่างรวดเร็วและง่ายดาย อย่างไรก็ตาม มันเป็นปกติสำหรับวัตถุสตริงและอาร์เรย์มีขนาดใหญ่มากและมันจะไม่ได้ผลมากว่าเหล่านี้ประเภทของข้อมูลที่คัดลอกบนพื้นฐานปกติ โชคดีที่ไม่จําเป็นต้อง ; พื้นที่จัดเก็บจริงสำหรับสินค้าขนาดใหญ่ที่ถูกจัดสรรจากกองเล็กๆ " ชี้ " ค่าใช้จำตำแหน่งของมัน จากนั้น เพียงชี้ต้องถูกคัดลอกในพารามิเตอร์ผ่าน ตราบใดที่ระบบ runtime สามารถหาข้อระบุชี้สำเนาเดียวของข้อมูลสามารถใช้บ่อยเท่าที่จำเป็นประเภทที่ถูกเก็บไว้โดยตรงและคัดลอกระหว่างผ่านตัวแปรที่เรียกว่าประเภทค่า เหล่านี้รวมถึงจำนวนเต็ม , ลอย , บูลีนและชนิดของซอฟต์แวร์ ( เช่นความสามัคคีสีและ vector3 ) ประเภทที่จัดสรรในกอง และเข้าถึงได้ผ่านตัวชี้จะเรียกว่าประเภทอ้างอิง เนื่องจากค่าเก็บไว้ในตัวแปรเพียง " หมายถึง " ข้อมูลที่แท้จริง ตัวอย่างของประเภทของการอ้างอิงรวมถึงวัตถุสตริงและอาร์เรย์ .การจัดสรรและการจัดเก็บขยะผู้จัดการหน่วยความจำติดตามพื้นที่ในกองที่รู้ว่าจะไม่ได้ใช้งาน เมื่อมีบล็อกใหม่ของหน่วยความจำการร้องขอ ( พูดเมื่อวัตถุ instantiated ) ผู้จัดการเลือกพื้นที่ไม่ได้ใช้จากที่จัดสรรไว้แล้วค่อยเอาจัดสรรหน่วยความจำจากรู้จักที่ไม่ได้ใช้พื้นที่ ขอตามมาจัดการเหมือนกัน จนกว่าจะไม่มีขนาดใหญ่เพียงพอที่จะจัดสรรพื้นที่ฟรีใช้บล็อกขนาด มันไม่น่าจะเกิดขึ้นได้ ณจุดนี้ว่า หน่วยความจำที่จัดสรรจากกองจะยังคงใช้ สินค้าอ้างอิงบนกองสามารถเข้าถึงได้ตราบเท่าที่ยังคงมีตัวแปรอ้างอิงที่สามารถค้นหา ถ้าอ้างอิงถึงบล็อกหน่วยความจำจะหายไป ( เช่นการอ้างอิงตัวแปรที่ได้กำหนด หรือมีตัวแปรท้องถิ่นที่มีตอนนี้จากขอบเขต ) แล้วความจำมันใช้อย่างปลอดภัยสามารถจัดสรรใหม่ .ไปตรวจสอบที่กองบล็อกจะไม่ได้ใช้งาน , จัดการหน่วยความจำค้นหาผ่านทั้งหมดในปัจจุบันใช้งานอ้างอิงตัวแปรและเครื่องหมายบล็อกที่พวกเขาจะเรียกว่า " สด " ในตอนท้ายของการค้นหาใด ๆ ช่องว่างระหว่างบล็อกสดถือว่าว่างเปล่าโดยผู้จัดการหน่วยความจำและสามารถใช้ในภายหลังเพื่อการ . สำหรับเหตุผลที่ชัดเจน กระบวนการของการค้นหา และเพิ่มหน่วยความจำที่ไม่ได้ใช้เป็นที่รู้จักกันเป็นเก็บขยะ ( หรือ GC สำหรับสั้น )เพิ่มประสิทธิภาพเก็บขยะอัตโนมัติและมองไม่เห็นโปรแกรมเมอร์แต่กระบวนการคอลเลกชันจริง ๆต้องใช้ CPU เวลาทางเบื้องหลัง เมื่อใช้อย่างถูกต้อง , การจัดการหน่วยความจำอัตโนมัติโดยทั่วไปจะเท่ากับ หรือเอาชนะคู่มือการจัดสรรสำหรับประสิทธิภาพโดยรวม อย่างไรก็ตาม , มันเป็นสิ่งสำคัญสำหรับโปรแกรมเมอร์ที่จะหลีกเลี่ยงความผิดพลาดที่จะเรียกเก็บเพิ่มเติมมักจะมากกว่าที่จำเป็น และแนะนำการหยุดในการมีวิธีการบางอย่างที่น่าอับอายที่สามารถ GC ฝันร้ายแม้ว่าพวกเขาดูเหมือนบริสุทธิ์ครั้งแรก ย้ำสายเรียงต่อกันเป็นตัวอย่างคลาสสิก