Software transactional protection of managed pointers

• US 20080034359A1
• Filed: 08/04/2006
• Published: 02/07/2008
• Est. Priority Date: 08/04/2006
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Duffy, John Joseph, Graefe, Goetz, Detlefs, David, Magruder, Michael M.
• Granted Patent: US 8,601,456 B2
• Time in Patent Office: Days
• US Class Current: 717/152
• CPC Class Codes: G06F 8/434 Pointers; Aliasing
• CPC Class Codes: G06F 8/4441 Reducing the execution time required by the program code
• CPC Class Codes: G06F 9/4484 Executing subprograms
• CPC Class Codes: G06F 9/466 Transaction processing

Abstract

Various technologies and techniques are disclosed that provide software transactional protection of managed pointers. A software transactional memory system interacts with and/or includes a compiler. At compile time, the compiler determines that there are one or more reference arguments in one or more code segments being compiled whose source cannot be recovered. The compiler executes a procedure to select one or more appropriate techniques or combinations thereof for communicating the sources of the referenced variables to the called code segments to ensure the referenced variables can be recovered when needed. Some examples of these techniques include a fattened by-ref technique, a static fattening technique, a dynamic ByRefInfo type technique, and others. One or more combinations of these techniques can be used as appropriate.

Claims

1. A method for providing software transactional protection of managed pointers comprising the steps of:

at compile time, determining that there are one or more variables being passed by reference to separately compiled code segments in at least one code segment being compiled;

selecting at least one technique for communicating the sources of the variables being passed by reference;

modifying the at least one code segment to implement the selected technique; and

creating an executable using the modified code segment.

2. The method of claim 1, wherein the at least one technique is a fattened by-ref technique, and wherein the technique comprises:

creating a new by-ref info type that contains information necessary to distinguish different kinds of actual arguments;

for a method that has at least one by-ref argument, change the by-ref argument to include an additional argument for a variable using the new by-ref info type; and

at a call site for the method that has the at least one by-ref argument, inserting code to assign an appropriate one or more values to the new by-ref info type, and adding the type as a call site argument to the call to the method.

3. The method of claim 1, wherein the at least one technique is a modified fattened by-ref technique that uses enumerations and structures, and wherein the technique comprises:

at each call site that invokes a particular method that has reference arguments needing identified, allocating a by-ref information holder; and

passing the by-ref information holder by reference.

4. The method of claim 3, wherein the by-ref information holder is an instance of one of a plurality of pre-defined value types.

5. The method of claim 1, wherein the at least one technique is a static fattening technique, and wherein the technique comprises:

creating a global table for storing static by-ref information; and

when compiling a call to a method accepting one or more by-ref arguments, adding static by-ref information entries to the global table describing the actual arguments to the one or more by-ref arguments, for later retrieval.

6. The method of claim 5, further comprising:

at runtime, when a method is being executed and an access involving a by-ref argument is encountered, indexing a global table to discover the static by-ref information.

7. The method of claim 6, wherein the indexing of the global table is achieved by using knowledge of an address of an instruction that invoked the method.

8. The method of claim 1, wherein the at least one technique comprises a plurality of techniques that are used in combination.

9. The method of claim 1, wherein technique is selected from the group consisting of a fattened by-ref technique, a modified fattened by-ref technique, and a static fattening technique.

10. A computer-readable medium having computer-executable instructions for causing a computer to perform the steps recited in claim 1.

11. A method for providing software transactional protection of managed pointers comprising the steps of:

determining that a static fattening technique should be used to allow a source of a particular reference argument to be recovered when needed;

at compile time, creating a static data structure for storing static by-ref information about the particular reference argument;

creating a global table for storing static by-ref information; and

when compiling a call to a method accepting the particular reference argument, adding static by-ref information entries to the global table describing the actual arguments to the particular reference argument, for later retrieval.

12. The method of claim 11, further comprising:

at runtime, when a method is being executed, and an access involving the particular reference argument is encountered, determining an address of the call site that invoked the method by a return address of the method.

13. The method of claim 12, wherein the return address is used to index a global table in which static by-ref info is stored.

14. The method of claim 13, further comprising:

locating a calling stack frame in which a caller recorded an actual reference or other information describing a by-ref argument at a fixed known offset in that stack frame.

15. A computer-readable medium having computer-executable instructions for causing a computer to perform the steps recited in claim 11.

16. A computer-readable medium having computer-executable instructions for causing a computer to perform steps comprising:

at compile time, determine that there is a first argument and a second argument referenced in at least one code segment being compiled whose source cannot be recovered;

select at least one technique for communicating a first source of the first argument;

select at least one technique for communicating a second source of the second argument, the second technique solving a problem that is only present with the second argument and not the first argument; and

modify the at least one code segment to implement the first technique for the first argument and the second technique for the second argument.

17. The computer-readable medium of claim 16, wherein the first technique is implemented using a static fattening technique.

18. The computer-readable medium of claim 16, wherein the problem that is only present with the second argument is that a value of the second argument is not known until runtime.

19. The computer-readable medium of claim 18, wherein the problem is solved using a dynamic by-ref info type technique.

20. The computer-readable medium of claim 16, further having computer-executable instructions for causing a computer to perform the step comprising:

create an executable using the modified code segment.