Patent Grant
10628306
Garbage collection is a form of automatic memory management in computing systems. A garbage collector attempts to detect objects no longer used by software applications or programs on the computer system and to recover memory occupied by the objects that are no longer used by software applications or programs running on the computing system. In one example, garbage collection can be contrasted with manual memory management in which a programmer specifies the objects to de-allocate and return to the memory system. Memory management, including garbage collection, can influence performance of the software applications running on the computing device.
Many programming languages include garbage collection. In some programming languages, garbage collection can be included as part of the language specification such as C#, Java, D, Go, and many scripting languages. Additionally, some languages such as C and C++ are designed for manual memory management but include garbage-collected implementations. Further, some languages such as C++ for Common Language Infrastructure (C++/CLI) allow for both garbage collection and manual memory management to co-exist in the same application by using separate memory segments for collected and manually managed objects. Garbage collection is often integrated into the language compiler and the runtime system.
This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
Systems and methods for garbage collection are disclosed. In one example, the garbage collection is a concurrent garbage collection provided in a dedicated thread concurrently running in the computing device with a mutator thread. The concurrent garbage collection is triggered based on a dynamically tunable parameter from a previous garbage collection in closed loop feedback. The current trigger, or new output can be based on one or more of plurality of factors including the error and the previous output. For example, a first factor can include accounting for present values of error from a set point, or goal. A second factor can include accounting for past values of the error. A third factor can account for possible future trends of the error and can be based on a current rate of change. In one example, the third factor can be optionally or selectively applied.
The accompanying drawings are included to provide a further understanding of embodiments and are incorporated in and constitute a part of this disclosure. The drawings illustrate embodiments and together with the description serve to explain principles of embodiments. Other embodiments and many of the intended advantages of embodiments will be readily appreciated, as they become better understood by reference to the following description. The elements of the drawings are not necessarily to scale relative to each other. Like reference numerals designate corresponding similar parts.
In the following Description, reference is made to the accompanying drawings, which form a part hereof, and in which is shown by way of illustration specific embodiments in which the invention may be practiced. It is to be understood that other embodiments may be utilized and structural or logical changes may be made without departing from the scope of the present invention. The following description, therefore, is not to be taken in a limiting sense. It is to be understood that features of the various exemplary embodiments described herein may be combined with each other, unless specifically noted otherwise.
The exemplary computer system includes a computing device, such as computing device 100. In a basic hardware configuration, computing device 100 typically includes a processor system having one or more processing units, i.e., processors 102, and memory 104. By way of example, the processing units may include two or more processing cores on a chip or two or more processor chips. In some examples, the computing device can also have one or more additional processing or specialized processors (not shown), such as a graphics processor for general-purpose computing on graphics processor units, to perform processing functions offloaded from the processor 102. The memory 104 may be arranged in a hierarchy and may include one or more levels of cache. Depending on the configuration and type of computing device, memory 104 may be volatile (such as random access memory (RAM)), non-volatile (such as read only memory (ROM), flash memory, etc.), or some combination of the two. The computing device 100 can take one or more of several forms. Such forms include a tablet, a personal computer, a workstation, a server, a handheld device, a consumer electronic device (such as a video game console or a digital video recorder), or other, and can be a stand-alone device or configured as part of a computer network.
Computing device 100 can also have additional features or functionality. For example, computing device 100 may also include additional storage. Such storage may be removable and/or non-removable and can include magnetic or optical disks, solid-state memory, or flash storage devices such as removable storage 108 and non-removable storage 110. Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any suitable method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Memory 104, removable storage 108 and non-removable storage 110 are all examples of computer storage media. Computer storage media includes RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile discs (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, universal serial bus (USB) flash drive, flash memory card, or other flash storage devices, or any other storage medium that can be used to store the desired information and that can be accessed by computing device 100. Accordingly, a propagating signal by itself does not qualify as storage media. Any such computer storage media may be part of computing device 100.
Computing device 100 often includes one or more input and/or output connections, such as USB connections, display ports, proprietary connections, and others to connect to various devices to provide inputs and outputs to the computing device. Input devices 112 may include devices such as keyboard, pointing device (e.g., mouse, track pad), stylus, voice input device, touch input device (e.g., touchscreen), or other. Output devices 111 may include devices such as a display, speakers, printer, or the like.
Computing device 100 often includes one or more communication connections 114 that allow computing device 100 to communicate with other computers/applications 115. Example communication connections can include an Ethernet interface, a wireless interface, a bus interface, a storage area network interface, and a proprietary interface. The communication connections can be used to couple the computing device 100 to a computer network, which can be classified according to a wide variety of characteristics such as topology, connection method, and scale. A network is a collection of computing devices and possibly other devices interconnected by communications channels that facilitate communications and allows sharing of resources and information among interconnected devices. Examples of computer networks include a local area network, a wide area network, the Internet, or other network.
Computing device 100 can be configured to run an operating system software program and one or more computer applications, which make up a system platform. A computer application configured to execute on the computing device 100 includes at least one process (or task), which is an executing program. Each process provides the resources to execute the program. One or more threads run in the context of the process. A thread is the basic unit to which an operating system allocates time in the processor 102. The thread is the entity within a process that can be scheduled for execution. Threads of a process can share its virtual address space and system resources. Each thread can include exception handlers, a scheduling priority, thread local storage, a thread identifier, and a thread context, or thread state, until the thread is scheduled. A thread context includes the thread's set of machine registers, the kernel stack, a thread environmental block, and a user stack in the address space of the process corresponding with the thread. Threads can communicate with each other during processing through techniques such as message passing.
An operation may execute in a thread separate from the main application thread. When an application calls methods to perform an operation, the application can continue executing on its thread while the method performs its task. Concurrent programming for shared-memory multiprocessors can include the ability for multiple threads to access the same data. The shared-memory model is the most commonly deployed method of multithread communication. Multiple threads execute on multiple processors, multiple processor cores, multiple logical nodes in a single processor core, and/or other classes of parallelism that are attached to a memory shared between the processors.
The present disclosure relates generally to garbage collectors and methods to provide garbage collection, such as concurrent garbage collection, used with programming languages or runtime systems in a data processing system such as computing device 100. Aspects of the present disclosure may be embodied as a system, method or computer program product. Accordingly, aspects of the present disclosure may take the form of entirely hardware, entirely software, including firmware, resident software, micro-code, or a combination of software and hardware aspects that may all generally be referred to as a system. Furthermore, aspects of the present disclosure may take the form of a computer program product including one or more computer readable medium or media having computer readable program instruction for causing a processor to carry out the aspects of the disclosure.
Class library 202 of the example can include one or more class or classes 206 implemented in accordance with the methods disclosed. In general, a class 206 is an extensible program-code-template, or blueprint, for creating objects, providing initial values for state, and implementations of behavior. The class is a construct that enables a developer to create custom types by grouping together variables of other types, methods and events. Class or classes 206 may include class variables, instance variables, local variables, parameters, user-defined methods, inherited states and behaviors, and interfaces. The variable can remain in memory 104 until all references go out of scope. At that time, the runtime system 204 via garbage collector 208 can mark the variable as eligible for garbage collection.
Garbage collector 208 automatically manages the allocation and release of memory for the developer-written application. The runtime system 204 allocates a segment of memory 104 to store and manage objects called the managed heap. (In one example, the managed heap is distinguishable from a native heap in the operating system. For the purposes of this disclosure, “heap” refers to the managed heap.) For each new object, the runtime system 204 allocates memory for the object from the managed heap. In one example, there can be a managed heap for each managed process, and threads in the process allocate memory for objects on the same heap. In another example, the heap can be an accumulation of a large object heap, such as a heap that includes objects over a selected threshold in size, and a small object heap.
As address space becomes occupied on the managed heap, the garbage collector 208 eventually frees some memory. The garbage collector 208 includes an optimizing engine 212 to determine the preferred time or occasion to perform a collection, which can be based upon a dynamically tunable parameter from a previous garbage collection. The garbage collector 208 checks for objects in the managed heap that are no longer being used by the application and performs the operations to reclaim the memory. Garbage collection can occur when the system has low physical memory or if the memory used by allocated objects on the managed heap surpasses an acceptable threshold. In one example, the threshold can be dynamically adjusted as based on a previous garbage collection.
In one example, the heap can be a generational heap. The heap can be organized into multiple generations to tackle long-lived and short-lived objects. Garbage collection primarily occurs with the reclamation of short-lived objects that typically occupy a small part of the heap. One example includes three generations of objects on the heap including a generation 0, generation 1, and generation 2. Generation 0 is the youngest generation and contains short-lived objects such as a temporary variable. Garbage collection occurs most frequently in this generation. In one example, newly allocated objects form a new generation of objects and are implicitly generation 0 collections, unless they are large objects, in which case they go on the large object heap in a generation 2 collection. Many objects are reclaimed for garbage collection in generation 0 and do not survive to the next generation. Generation 1 includes short-lived objects and can serves as a buffer between short-lived objects and long-lived objects. Some example garbage collectors do not include a generation 1 heap and only include heaps for short-lived and long-lived objects. Additionally, one or more generations of short-lived objects can be known as ephemeral generations. Generation 2 includes long-lived objects. An example of a long-lived object is an object in a server application that contains static data that is live for the duration of the process. Garbage collections occur on specific generations as conditions warrant. Collecting a generation means collecting objects in that generation and all its younger generations. A generation 2 garbage collection is typically a full garbage collection because it reclaims all objects in all generations of the managed heap.
Objects that are not reclaimed in a garbage collection are known as survivors and are promoted to the next generation. For example, objects that survive a generation 0 garbage collection are promoted to generation 1, objects that survive a generation 1 garbage collection are promoted to generation 2, and objects that survive a generation 2 garbage collection remain in generation 2.
Before a garbage collection starts, or is triggered, the managed threads can be suspended except for the thread that triggered the garbage collection. The garbage collector can determine whether an object is live via information such as stack variables provided by a just-in-time compiler and stack walker, handles that point to managed objects and that can be allocated by user code or by the runtime, and from static objects in application domains that could be referencing other objects. Each application domain keeps track of its static objects. In one example, garbage collection can occur in a set of phases including marking phase that finds and creates a list of all live objects, a relocating phase that updates the references to the objects that will be compacted, and a compacting phase that reclaims the space occupied by the dead objects and compacts the surviving objects. The compacting phase moves objects that have survived a garbage collection toward the older end of the segment. In one example, garbage collector 208 can be a mark and sweep collector that can find and create a list of all live objects, update references to objects that occupy memory to be compacted, reclaim address space occupied by dead objects, and compact surviving objects.
Concurrent garbage collection is a form of garbage collection that enables threads to run concurrently with a dedicated thread that performs the garbage collection for at least some of the duration of the dedicated thread that performs the garbage collection. For example, a concurrent garbage collection can run in the dedicated thread while one or more mutator threads are running, i.e., a thread that mutates the managed heap. Concurrent garbage collection can be performed on generational and non-generational heaps. In one example, concurrent garbage collection affects garbage collections for long-lived objects such as generation 2. For example, garbage collection in generation 0 and generation 1 are performed non-concurrently because they can be completed quickly and not noticeably affect performance.
Concurrent garbage collection can enable some software applications to be more responsive by eliminating or reducing pauses of a software application for a garbage collection. Managed threads can continue to run for at least some of the time while the concurrent garbage collection thread is running. This can eliminate pauses or result in shorter pauses during a garbage collection. Concurrent garbage collection can trade some processor performance and memory for shorter pauses during garbage collection.
Concurrent garbage collector 208 attempts to improve performance via preferred triggering of the collection with optimizing engine 212. Concurrent garbage collector in general presents a performance overhead, and running too often or when not preferred can adversely affects performance of the concurrently running programs. If the collection is triggered to early, the free memory space has not been efficiently used and performance of the concurrently running programs is adversely affected. If the collection is triggered too late and the managed heap runs out of memory space, the generational size of the managed heap may need to be extended which adversely affects the performance of non-compacting concurrent garbage collectors. Performance of compacting concurrent garbage collectors can suffer as well as mutator threads may have to wait for more memory space to become available.
Concurrent garbage collection is affected by unpredictable factors such as operating system thread scheduling and sudden changes in application behavior as well as other factors. Due to the non-deterministic nature of these factors, predicting the pace of building free memory space and consuming the free memory space is difficult. Thus, triggering concurrent garbage collection from a statically preconfigured amount of free memory space left available in the managed heap is generally inefficient and can run the risk of either running out of free space, and having to acquire more memory from the operating system, or not utilizing the free space built up from a previous garbage collection.
In one example, the optimizing engine 212 schedules the garbage collection on a trigger based on closed-loop feedback. The input in one example is the error based on a goal that indicates an amount of free memory space when the free memory space is at the smallest such as right before the garbage collection is to be triggered, and the output can include an amount of memory that will be consumed in the free space by other generation allocations before the next concurrent collection is triggered. The output can be extended to any other kinds of factors that will denote the triggering of the next concurrent garbage collection, such as the number of younger generations garbage collections that will be performed before the next concurrent collection is triggered. In one example, an amount of free space is a ratio of free memory space to available memory space on the heap. In another example, the amount of free space can be a number of bytes of free memory.
To initialize the method 300, the optimizing engine can apply parameters initially configured by the runtime system 200. In one example, a user may further configure or selectively adjust the parameters. For instance, a free memory space goal amount of free space can be selected to include 15% of the heap. The initial trigger can include the goal amount plus an additional free space amount, such as 5%. For example, the initial garbage collection can be triggered when 20% of the heap is free memory space. An error amount can be set to include the difference between the actual amount of free space at trigger and the goal amount of free space.
In one example, first feedback factor at 402 includes a constant multiplied by the error amount and the second factor at 404 is the previous output. For example, new_output=previous_output*(1+constant*error_amount).
In this example, the value of constant can be selected to be in the range including 0.032 to 0.050. The new_output becomes the previous_output in subsequent garbage collections, and the error_amount is calculated as the difference between the output and the goal.
In one example, the third feedback factor at 406 can include the smaller of the adjustment to the trigger and a preselected amount. In one example, the adjustment can be expressed (new_output−previous_output)/previous_output
Thus, if the adjustment is greater than a preselected amount, such as X %, the third feedback factor applied is X %. In one example, the third feedback factor is not applied on each trigger. For example, the third feedback factor can be applied if the new_output crosses the goal amount. In another example of a third feedback factor applied on a crossing of the goal amount, the amount of the adjustment can be set to half of the previous_output and the new_output. In this example, an adjustment_amount added to the new output can be set to (new_output+previous_output)/2.
Although specific embodiments have been illustrated and described herein, it will be appreciated by those of ordinary skill in the art that a variety of alternate and/or equivalent implementations may be substituted for the specific embodiments shown and described without departing from the scope of the present invention. This application is intended to cover any adaptations or variations of the specific embodiments discussed herein.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5088036 | Ellis et al. | Feb 1992 | A |
| 6065020 | Dussud | May 2000 | A |
| 6393440 | Salant et al. | May 2002 | B1 |
| 6526421 | Houldsworth | Feb 2003 | B1 |
| 6839725 | Agesen et al. | Jan 2005 | B2 |
| 7174354 | Andreasson | Feb 2007 | B2 |
| 7197521 | Subramoney et al. | Mar 2007 | B2 |
| 7310655 | Dussud | Dec 2007 | B2 |
| 7672983 | Printezis et al. | Mar 2010 | B2 |
| 7962707 | Kaakani et al. | Jun 2011 | B2 |
| 8527560 | Lucco et al. | Sep 2013 | B2 |
| 8583783 | Hayward et al. | Nov 2013 | B1 |
| 20020147899 | Lewis | Oct 2002 | A1 |
| 20040111449 | Garthwaite | Jun 2004 | A1 |
| 20060155791 | Tene | Jul 2006 | A1 |
| 20060167961 | Fox | Jul 2006 | A1 |
| 20060230087 | Andreasson | Oct 2006 | A1 |
| 20070033240 | Barsness et al. | Feb 2007 | A1 |
| 20100114997 | Micic et al. | May 2010 | A1 |
| 20110264970 | Whetsel | Oct 2011 | A1 |
| 20120323979 | Basu | Dec 2012 | A1 |
| 20130091186 | Stephens et al. | Apr 2013 | A1 |
| 20150067293 | Flood | Mar 2015 | A1 |
| 20160098229 | Schreiber et al. | Apr 2016 | A1 |
| 20160140036 | O'meara et al. | May 2016 | A1 |
| 20160239413 | Stephens et al. | Aug 2016 | A1 |
| 20170344473 | Gidra | Nov 2017 | A1 |
| Number | Date | Country |
|---|---|---|
| 2009086424 | Jul 2009 | WO |
| Entry |
|---|
| Thompson, Martin, “Java Garbage Collection Distilled”, https://www.infoq.com/articles/Java_Garbage_Collection_Distilled, Jun. 17, 2013, 15 Pages. |
| “Tuning the Memory Management System”, https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/memman.html, Nov. 18, 2011, 9 pages. |
| “Tuning for a Small Memory Footprint”, https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/tune_footprint.html, Nov. 27, 2011, 3 pages. |
| “Debugging ART Garbage Collection”, https://source.android.com/devices/tech/dalvik/gc-debug.html, Oct. 6, 2015 , 6 pages. |
| “International Search Report and Written Opinion Issued in PCT Application No. PCT/US2018/015112”, dated Apr. 4, 2018, 9 Pages. |
| “International Search Report and Written Opinion Issued in PCT Application No. PCT/US2017/066240”, dated Mar. 15, 2018, 13 Pages. |
| “Non Final Office Action Issued in U.S. Appl. No. 15/422,131”, dated Sep. 7, 2018, 9 Pages. |
| “Final Office Action Issued in U.S. Appl. No. 15/422,131”, dated Apr. 1, 2019, 9 Pages. |
| “Non Final Office Action Issued in U.S. Appl. No. 15/422,131”, dated Jun. 13, 2019, 9 Pages. |
| Number | Date | Country | |
|---|---|---|---|
| 20180217927 A1 | Aug 2018 | US |
