Microsoft Technology Licensing, LLC

Wen-Ke Chen

Jinsong Yu

Sanjay Bhansali

Alexander P Riemann

Andrew James Edwards

Darek Josip Mihocka

Ho-Yuen Chau

Ronald C Murray

Xiaofeng Gao

Kenneth Bryant Pierce

Stuart D De Jong

Build-time resolution and type-enforcing of corresponding references in different code that references the same value. In response to detecting a directive within the code itself that a first reference in first code is to be correlated with a second reference in second code, and in response to detection that the types of the references are the same, a code generation tool generates correlation code that is interpretable to a compiler as allowing a value of a type of the first reference of a compiled-form of the first code to be passed as the same value of the same type of the second reference of a compiled-form of the second code. The first code, the second code, and the generated correlation code may then be compiled. If compilation is successful, this means that the first and second references are already properly resolved as referring to the same value and type-enforced.

Build-time resolving and type checking references

Input filters correlate to target components. For a given target component, the input filter defines input validation information. The input filter might also define conversions or transformations to be applied to valid input prior to being provided to the target component. At build time, code is accessed that contains the input validation, conversion and transformation and that identifies the associated target component. The information is then used to construct an input filter. At run time, when an input processing component receives an input, the input processing component identifies the target component, accesses the associated input filter, and uses the information contained in the input filter to determine whether the input is valid, and whether and how to convert and transform the value.

Input filters and filter-driven input processing

Applications written in modern garbage collected languages like C# tend to have large dynamic working sets and poor data locality and are therefore likely to spend excess time on managing data movements between memory hierarchies. Instead, a low overhead dynamic technology improves data locality of applications. The technology monitors objects while the program runs and places recently accessed objects on the same page(s) on the heap. Providing increased page density is an effective method for reducing DTLB and/or data cache misses.

Increasing data locality of recently accessed resources

Program execution can be monitored and recorded for later playback. Certain state changes that can be predicted via a virtual processor during playback need not be recorded, so a compressed recording can be stored. To facilitate random access with respect to time during playback, key frames can be stored within the compressed recording. An index mechanism can associate key frames with particular memory addresses. Additionally, a snapshot of values for memory addresses can be used to further facilitate determining the value of a memory address without having to simulate execution. Multiprocessor executions can be supported, and playback can be done on a machine type different from that on which recording took place.

Compressed program recording

Growing community of inventors

Redmond, WA, United States of America

Wen-Ke Chen