Microsoft Technology Licensing, LLC

Microsoft Corporation

Mark Ronald Plesko

David Read Tarditi, Jr

Timothy Lawrence Harris

Avraham E Shinnar

Vinod Grover

Christopher Wellington Brumme

Andrew James Edwards

Maoni Zhang Stephens

David Mitford Gillies

Eric Dean Tribble

Charles L Mitchell

Mark L Roberts

Julian Burger

Andrew Edward Ayers

Akella V S Sastry

Ying Hung Au

Manish Godse

Mukund Raghav Sharma

Some embodiments perform lightweight monitoring for garbage collection (GC) flow events, then perform focused tracing after detecting a performance problem signal. The tracing is focused by constraints which are specified in a designation data structure, including a performance problem signal definition, a corresponding trace data category and a corresponding tracing stop trigger. Tracing is done only in the specified category and only for the specified time period, to reduce or avoid collection of irrelevant trace data and to reduce or avoid changes in program behavior caused by the tracing itself. Some designation data structures also specify a corresponding trace data analysis. In operation, some embodiments dynamically re-focus tracing on an offshoot trace in response to a trace data analysis result obtained while the program is still executing.

Garbage collection lightweight dynamic tracing and analysis

A software transactional memory system is described which utilizes decomposed software transactional memory instructions as well as runtime optimizations to achieve efficient performance. The decomposed instructions allow a compiler with knowledge of the instruction semantics to perform optimizations which would be unavailable on traditional software transactional memory systems. Additionally, high-level software transactional memory optimizations are performed such as code movement around procedure calls, addition of operations to provide strong atomicity, removal of unnecessary read-to-update upgrades, and removal of operations for newly-allocated objects. During execution, multi-use header words for objects are extended to provide for per-object housekeeping, as well as fast snapshots which illustrate changes to objects. Additionally, entries to software transactional memory logs are filtered using an associative table during execution, preventing needless writes to the logs. Finally a garbage collector with knowledge of the software transactional memory system compacts software transactional memory logs during garbage collection.

Compiler support for optimizing decomposed software transactional memory operations

The coordination and execution of chores in a multiprocessing environment. The coordination of chores is accomplished utilizing a compiler generated correlation that relates blocks of code that execute chores and blocks of code in which the chore can be realized. By tracking the execution of the program and using the compiler-generated correlation, chores can be identified for the currently executing code.

Coordinating chores in a multiprocessing environment using a compiler generated exception table

Reducing unnecessary software transactional memory operations on newly-allocated data

Removal of unnecessary read-to-update upgrades in software transactional memory

A representation of types, type-checker, method and compiler are provided for checking consistency in various forms of an intermediate language. Specifically, the typed intermediate language is suitable for use in representing programs written in multiple (heterogeneous) source languages including typed and untyped languages, loosely and strongly typed languages, and languages with and without garbage collection. Additionally, the type checker architecture is extensible to handle new languages with different types and primitive operations. The representation of types can be implemented as a data structure that represents two or more sets of types with one or more sub-structures for representing classifications of types. Alternatively, the type system can be implemented as a base class at the top of a hierarchy and a plurality of classes hierarchically below the base class can be defined to represent a number of types such as pointer types, container types, and function types.

Representing type information in a compiler and programming tools framework

A software development architecture is provided for constructing a wide range of software development tools. A software development tool can be created by integrating a specification specifying functionality specific to a set of software development scenarios into a software development scenario-independent framework. The integrated specification can then be compiled to create the software development tool. Alternatively, integration can be achieved at runtime without access to source code. The architecture can use any combination of the following: a software scenario independent intermediate representation format, one or more exception handling models capable of supporting a plurality of programming language specific exception handling models, a type system capable of representing the type representations of a plurality of source languages, and a code generator capable of generating code targeted for a plurality of execution architectures.

Software development infrastructure

A representation of types, type-checker, method and compiler are provided for checking consistency in various forms of an intermediate language. Specifically, the typed intermediate language is suitable for use in representing programs written in multiple (heterogeneous) source languages including typed and untyped languages, loosely and strongly typed languages, and languages with and without garbage collection. An unknown type representation indicates that an element of the intermediate language is associated with an unknown type. A method of type-checking a code segment written in a programming language is provided using a rule set that contains rules for type-checking an unknown type. The unknown type allows for selectively retaining type information as the compilation process continues and allows multiple programming languages to be type-checked by the same type system.

Type system for representing and checking consistency of heterogeneous program components during the process of compilation

Filtering of transactional memory operations using associative tables

A representation of types, type-checker, and compiler are provided for checking consistency in various forms of an intermediate language. Type-checking a programming language in a compiler is accomplished by taking one or more rule sets as input to a type-checker, which selects one or more of the rule sets based upon any one, or combination of two or more, of numerous criteria. Among them are stage of compilation, source language, architecture, and level of typing present in the language being type-checked. The language is then type-checked using the selected one or more rule sets. The rule sets can include one rule set corresponding to strong type-checking, one rule set corresponding to weak type-checking, and one rule set corresponding to representation type-checking. In the alternative, a compiler can be provided with a type-checker that constructs the one or more sets of rules at runtime from a larger set of rules based on any one, or combination of two or more, of the previously mentioned criteria.

Extensible type system for representing and checking consistency of program components during the process of compilation

Growing community of inventors

Kirkland, WA, United States of America

Mark Ronald Plesko