Dynamically sized locals with precise garbage collection reporting

Patent metadata

Field	Value
Publication number	US-10127151-B2
Application number	US-201615153755-A
Country	US
Kind code	B2
Filing date	May 13, 2016
Priority date	May 13, 2016
Publication date	Nov 13, 2018
Grant date	Nov 13, 2018

Abstract

An instance of universally shared generic code is generated. A runtime parameter enables the size of a stack frame on which local data can be stored to be determined. Dynamically sized locals can be stored on a stack enabling precise garbage collection reporting. One frame of the stack is allocated for each code segment to simplify GC reporting. A reporting region in the frame memory region comprises a count of locals and a location at which the local is found in the stack.

First claim

What is claimed:

1. A computing device comprising:
at least one processor; and
a memory connected to the at least one processor;
wherein the at least one processor is configured to:
execute a single instance of universally shared generic code that works for all data types of variables and/or objects in each instantiation of corresponding generic source code by performing actions to:
allocate space on a stack, instead of a garbage collection heap, for local data;
store local data on the stack, wherein the local data is variably sized;
store a description of the stored local data on the stack; and
provide precise garbage collection (GC) reporting information to a subsequent process, wherein the precise GC reporting information indicates precisely where in the stack the local data is to be reclaimed.

2. The computing device of claim 1 , further comprising:
at least one program module that:
dynamically determines size of a stack frame to allocate for the local data based on at least one generic context parameter comprising a type description associated with the local data.

3. The computing device of claim 2 , wherein the at least one processor is further configured to:
receive the at least one generic context parameter at runtime.

4. The computing device of claim 1 , wherein the at least one processor is further configured to:
receive the at least one generic context parameter at runtime from which a size of the stack frame to be created is determined.

5. The computing device of claim 1 , wherein the at least one processor is configured to:
tell a subsequent process where the local data for garbage collection can be found.

6. The computing device of claim 1 , wherein the at least one processor is further configured to:
allocate space on the stack for local data associated with a particular execution of the universally shared generic code.

7. The computing device of claim 1 , wherein size of an allocated stack frame varies in accordance with size of the local data.

8. A method, comprising:
receiving by a processor of a computing device at runtime a single instance of universally shared generic code that works for all possible data types of variables and/or objects in each instantiation of generic code;
receiving a generic context parameter;
executing the single instance of universally shared generic code, wherein the behavior of the single instance of universally shared generic code is determined by the generic context parameter received at runtime, the single instance of universally shared generic code storing local data on a stack during runtime instead of on a garbage collection (GC) heap; and
generating precise garbage collection reporting information that indicates precisely where in the stack the local data is to be reclaimed.

9. The method of claim 8 , further comprising:
determining size of the stack based on a type description.

10. The method of claim 8 , further comprising:
receiving a generic context parameter comprising a type description for local data to be stored on the stack.

11. The method of claim 8 , further comprising:
receiving a generic context parameter at runtime from which stack size is dynamically determined.

12. A computing device comprising:
at least one processor; and
a memory connected to the at least one processor;
wherein the at least one processor is configured to:
receive generic source code;
generate a single instance of universally shared generic code that works for all possible data types of variables and/or objects in each instantiation of the generic code from the generic source code;
generate metadata for the universally shared generic code during compile time that is associated with field layouts and instance sizes of generic types in the generic source code; and
utilize the metadata and a generic context parameter, at runtime, to determine a size for a stack frame of a stack to allocate local data of the universally shared generic code in the stack instead of a garbage collection heap.

13. The computing device of claim 12 , wherein the at least one processor is further configured to:
provide precise garbage collection (GC) reporting information to a subsequent process, wherein the precise GC reporting information indicates precisely where in memory the local data is to be reclaimed.

14. The computing device of claim 13 , wherein the at least one processor is further configured to:
at runtime keep track of where a particular piece of local data is stored on the stack.

15. The computing device of claim 14 , wherein the at least one processor is further configured to:
tell a garbage collector when the local data can be garbage collected.

16. The computing device of claim 15 , wherein the at least one processor is further configured to:
tell the garbage collector where on the stack the local data that can be reclaimed is found.

17. The computing device of claim 13 , wherein each code segment of the generic source code is assigned a frame on the stack.

18. The computing device of claim 13 , wherein the stack comprises a reporting area.

19. The computing device of claim 12 , wherein the universally shared generic code is generated in response to receiving no parameter at compile time.

Assignees

• Microsoft Technology Licensing Llc
• Microsoft Technology Licensing Llc

Inventors

• Wrighton David C
• Mosier Scott D
• Hanna Fadi M
• Sollich Peter F
• Kotas Jan

Classifications

• G06F12/0223

  User address space allocation, e.g. contiguous or non contiguous base addressing · CPC title

• G06F2212/1044

  Space efficiency improvement · CPC title

• G06F8/41

  Compilation · CPC title

• G06F12/0238

  Memory management in non-volatile memory, e.g. resistive RAM or ferroelectric memory · CPC title

• G06F9/44563

  Sharing · CPC title