Microsoft Technology Licensing, LLC

Richard Byers

Jonathon Michael Stall

Gregg Bernard Miskelly

Hsu-chieh Yuan

Raja Krishnaswamy

Jonathan White Keljo

Thomas Lai

Frank V Peschel-Gallee

Kinshumann Kinshumann

Jesse Daniel Kaplan

Mark Allen Miller

David S Mortenson

Sean Selitrennikoff

Kumar Gaurav Khanna

Ladislav Prosek

Simon Jeremy Hall

Eric H Feiveson

Luiz F Santos

Richard E Lander

Cristian G Petruta

Varun Bahl

J Michael Stall

Jon Langdon

Jan Stranik

Vipul D Patel

Steve J Steiner

A library management system may compare contracts between programming libraries to identify unions, intersections, and differences between libraries. The management system may have a contract analyzer that may remove the contract definition from an existing library to form a library contract. The library contract may be managed as a first class item within a programming environment, and may be used as a reference for comparing existing and new versions of the library. The library management system may create reference libraries for programmers to write applications using two or more intersecting libraries, among other uses.

Library conformity checker

A runtime activation system uses a set of policies designed to provide a balance between backwards compatibility and ease of migrating existing (non side-by-side aware) applications to new runtime versions. The system chooses the runtime version to activate when an application runs or when a runtime application programming interface is invoked based on the set of policies. The system implements these policies by consulting compatibility data associated with the application indicating the intent of the author and level of side-by-side support provided by the application and/or global configuration data. Based on the compatibility data, the system chooses policies that are right in the most common cases, and easy to modify in less common cases. Thus, the runtime activation system allows applications to be flexibly configured to handle new runtime versions in a manner determined by the application author, a system administrator, or others.

Runtime activation and version selection

An error reporting system within the operating system of a computer that provides error reporting and/or debugging for managed applications. The error reporting service supports a registration programming interface through which applications that use non-native or non-standard error reporting functions can register runtime exception modules. A similar interface may be provided for applications to register debuggers. In response to a failure, such as a crash or an application hang, the error reporting service can poll the registered components to ascertain whether any is adapted for use in conjunction with such a failure. If so, the appropriate registered components can be used to collect failure data and/or debug the failed application. In this way, the error reporting service, and an existing framework that supports aggregation of application error reports, can be customized, including to allow error reporting and debugging of non-native applications.

System and method for customized error reporting

Systems and methods are described for coordinating error reporting among a plurality of managed runtimes that are concurrently executing in the same process. In accordance with various embodiments, an error reporting manager that executes concurrently in the same process as the managed runtimes coordinates error reporting among the managed runtimes in a manner that does not require the managed runtimes to be aware of each other or to communicate directly with each other.

Coordination of error reporting among multiple managed runtimes in the same process

The present invention extends to methods, systems, and computer program products for simulating operations through out-of-process execution. When a diagnostic operation is to be performed for a target execution context, a separate execution context is created based on the same executable code used to create the target execution context. An execution boundary separates the target execution context and the separate execution context such that execution in the separate execution context does not influence the behavior of the target execution context. State data from the target execution context is marshaled and transferred to the separate execution context. The separate execution context reconstitutes the state data and uses the state data to perform the diagnostic operation. Accordingly, performance of the diagnostic operation is simulated in the separate execution context without influencing the behavior of the target execution context.

Simulating operations through out-of-process execution

An in-process debugging experience can be implemented using an infrastructure that supports out-of-process debugging. A program that is to be debugged may be written in a command-line language that receives and processes input through an input loop. The interpreter for the language runs in a first process. A helper program is started in a second process, and attaches to the first process as if it were an out-of-process debugger. A debugging module is loaded into the interpreter, which provides user debugging commands that may utilize the helper program. When the program to be debugged generates a debug event, the event is received by the helper process, which uses a debug primitive to start a new instance of the input loop in the first process. Debugging commands provided by the debugging module can be entered by the user into the new instance of the input loop.

In-process debugging using external debugging infrastructure

A method and system to implement debugging interpreted input is described herein. One or more Intermediate Language (IL) islands are generated. Each IL island maps to one or more lines of source code. The interpreter reads a line of source code and parses the line of source code for a command. Before executing the command, the interpreter may call into the corresponding IL island. The IL island may include a breakpoint that corresponds to a set breakpoint in the mapped one or more lines of source code. The IL island may include a function. When calling the IL island, the interpreter may pass in a function pointer, one or more states of one or more variables, a representation of a call stack, or any other parameters. The IL islands enable a debug tool to do source-level debugging of languages executed by an interpreter without architectural changes to the interpreter.

Debugging interpreted input

Instruction sets in computing environments may execute within one of several domains, such as a natively executing domain, an interpretively executing domain, and a debugging executing domain. These domains may store values in a shared region of memory in different ways. It may be difficult to perform operations on such values, particularly if a domain that generated a particular value cannot be identified or no longer exist, which may obstruct shared accessing of values and evaluative tasks such as stack walks. Instead, accessors may be associated with a stored value that perform various operations (such as low-level assembly instructions like Load, Store, and Compare) according to the standards of the value-generating domain, and domains may be configured to operate on the value through the accessors. This configuration may promote consistent accessing of values without having to identify or consult the value-generating domain or reconfiguring the instruction sets.

Stored value accessors in shared memory regions

Growing community of inventors

Bellevue, WA, United States of America

Richard Byers