Microsoft Technology Licensing, LLC

International Business Machines Corporation

Microsoft Corporation

Vance Palmer Morrison

Patrick Henri Dussud

John Joseph Duffy

Christopher Wellington Brumme

Sean Edwin Trowbridge

James S Miller

Brian D Harry

David L Detlefs

Michael M Magruder

David S Callahan

Andrew Donald Gordon

Brian M Grunkemeyer

Eric Dean Tribble

Jason L Zander

William G Evans

Jennifer A Hamilton

Gopala Krishna R Kakivaya

Niklas Gustafsson

Eric Lynn Eilebrecht

Jonathan White Keljo

Peter A Hallam

David S Mortenson

Shajan Dasan

Bradley Moore Abrams

Sean Selitrennikoff

Donald Syme

David Michael Broman

George Harold Bosworth

Hsu-chieh Yuan

Sanjay Bhansali

Lawrence B Sullivan

Jonathon Forbes

Henricus Johannes Maria Meijer

Li Zhang

Anders Hejlsberg

Steven E Lucco

Stephen Harris Toub

Joseph L Hellerstein

Paul F Ringseth

Matthew J Warren

Dinesh Chandrakant Kulkarni

Gregory Darrell Fee

Gary Shon Katzenberger

Igor Ostrovsky

Luca Bolognese

Christopher W Fraser

Brian Robert Crawford

Robert S Wahbe

John Lawrence Hamby

Mahesh Prakriya

Jan Kotas

Andrew L Bliss

Jonathan A Forbes

Louis Lafreniere

Huseyin Serkan Yildiz

James H Hogg

Sebastian Lange

Sam Spencer

Joshua Ryan Williams

John Joseph Rivard

Douglas Jay Rosen

Steven J Steiner

Wilson D Lee

Shrikrishna Vijaykumar Borde

Ian H Carmichael

Feng Yuan

Cynthia Ann Rogers

Mario Chenier

Subramanian Ramaswamy

Simon Jeremy Hall

Peter Kukol

Tracy Kim Burroughs

Joe Duffy

Laura Jane Zaborowski

Ashok Cholpady Kamath

Dario Russi

David J Hiniker-Roosa

Habib Heydarian

Daniel Joshua Taylor

Lawrence Brozak Sullivan, Jr

Steven John Gansemer

Sedar Gokbulut

Don Syme

Erika Fuentes

Bryan P Arant

Brian F Sullivan

Cosmin Radu

Harry D Brian

George H Bosworth

Christopher W Brumme

Fine-grained parallelism within isolated object graphs is used to provide safe concurrent operations within the isolated object graphs. One example provides an abstraction labeled IsolatedObjectGraph that encapsulates at least one object graph, but often two or more object graphs, rooted by an instance of a type member. By encapsulating the object graph, no references from outside of the object graph are allowed to objects inside of the object graph. Also, the encapsulated object graph does not contain references to objects outside of the graphs. The isolated object graphs provide for safe data parallel operations, including safe data parallel mutations such as foreach loops. In an example, the ability to isolate the object graph is provided through type permissions.

Concurrent mutation of isolated object graphs

Computer systems attempt to manage resource pools of a dynamic number of similar resources and work tasks in order to optimize system performance. Work requests are received into the resource pool having a dynamic number of resources instances. An instance-throughput curve is determined that relates a number of resource instances in the resource pool to throughput of the work requests. A slope of a point on the instance-throughput curve is estimated with stochastic gradient approximation. The number of resource instances for the resource pool is selected when the estimated slope of the instance-throughput curve is zero.

Managing pools of dynamic resources

Fine-grained parallelism within isolated object graphs is used to provide safe concurrent operations within the isolated object graphs. One example provides an abstraction labeled IsolatedObjectGraph that encapsulates at least one object graph, but often two or more object graphs, rooted by an instance of a type member. By encapsulating the object graph, no references from outside of the object graph are allowed to objects inside of the object graph. Also, the encapsulated object graph does not contain references to objects outside of the graphs. The isolated object graphs provide for safe data parallel operations, including safe data parallel mutations such as for each loops. In an example, the ability to isolate the object graph is provided through type permissions.

A debugging system for compiled code may include static analysis of the compiled code to determine current values for variables at a paused location within the compiled code. The static analysis may consist of liveness analysis to determine which variables are 'live' and in which memory locations those variables are stored. The variables and their values may be presented to a user. The debugging system may include mechanisms for setting stop points, for pausing and continuing execution, as well as stepping through a step or group of steps. Other static analysis may include unwind information that may determine a point in the code from where the current function was called, as well as partial decompilation of the source code to produce a representation of the compiled code that is closer to that of the source code.

Debugging system using static analysis

Activity-based sampling provides useful and relevantly focused diagnostic data, connected to improve a developer's understanding. An application invokes log-event procedures, causing a logger to check logging conditions and make a log entry when a logging condition is satisfied. The logger has a set of log-enabled activities, and one or more start-events with respective sampling frequency conditions. One logging condition is that a current activity-id be log-enabled. Another states that if the current activity-id is not log-enabled but the log-event procedure identifies a start-event consistent with the sampling frequency condition, the activity is log-enabled and a log entry is made. Creation of a child activity by a parent activity which is in the set of log-enabled activities is noted in the log, and the child is automatically log-enabled. A log consumer may reside inside or outside the application. Event Tracing for Windows services can be enhanced to support activity-based sampling.

Activity based sampling of diagnostics data

A software optimization system isolates an effect of a change in a control variable from effects of ongoing, unknown changes in other variables. The system discards effects due to noise so that effects of interest to a programmer are more easily visible. The software optimization system treats variations in one or more control variables and in the output of the system as signals. The system varies the control variable at a specific frequency unlikely to correlate with uncontrolled variations in external variables. The system uses digital signal processing (DSP) techniques to filter the output, isolating the frequency of the control variable variation. The system then compares the resulting filtered output to the input to determine the approximate effect of the variation in the control variable.

Isolating changes in dynamic systems

A parallelism policy object provides a control parallelism interface whose implementation evaluates parallelism conditions that are left unspecified in the interface. User-defined and other parallelism policy procedures can make recommendations to a worker program for transitioning between sequential program execution and parallel execution. Parallelizing assistance values obtained at runtime can be used in the parallelism conditions on which the recommendations are based. A consistent parallelization policy can be employed across a range of parallel constructs, and inside recursive procedures.

Controlling parallelization of recursion using pluggable policies

A profiler may be detached from an actively running application by first sealing communications between the application and profiler, then evacuating the profiler by waiting for any profiler-modified or instrumented code to complete execution, profiler runtime code to complete execution, cleaning up any residual items from the profiler, and shutting down the profiler. The profiler may be operational in many different environments, including a managed environment such as a virtual machine and those environments having just in time compiling of executable code.

Detaching profilers

Idle processor cores can be used to compile methods that are likely to be executed by a program based on profile data that is captured during one or more previous executions. Methods that are determined by the profile data to be likely to be used can be compiled eagerly on one or more background threads. Transparency can be achieved by ensuring that module load order is not altered because of the background threads by recording the state of loaded modules after each profiled compilation, persisting that data, and waiting to eagerly compile a method until the method to be compiled and all its dependencies has been loaded by the executing program.

Profile driven multicore background compilation

Particular portions of program execution data are specified and organized in semantic groups. A grouping expression written in a transformation syntax language specifies a pattern and a replacement, for grouping performance data samples. An exception to the pattern can also be specified. In response to the grouping expression, a cost accounting shows groups and their costs. The grouping expression may operate on names and/or name-associated characteristics such as private/public status, author, directory, and the like. Samples may represent nodes in a directed acyclic graph memorializing call stacks or memory allocation. Grouping expressions are used to group nodes and consolidate costs by various procedures when making modified sample stacks: clustering-by-name, entry-group-clustering, folding-by-name, a folding-by-cost. An entry group clustering shows at least one entry point name while avoiding unwanted detail.

Semantic grouping for program performance data analysis

Various technologies and techniques are disclosed for providing concurrent exception handling. When one or more exceptions are received from concurrent workers, one or more exception handler functions are supplied. For each respective exception in the exception results, determine if the respective exception is one of a kind of exceptions handled by the one or more exception handler functions. If the respective exception is one of a kind handled by the exception handler functions, then run a particular handler of the exception handler functions and mark the respective exception as handled. Any unhandled exceptions are then processed appropriately. In one implementation, a collection of input data is processed to produce a collection of output results, with the exceptions being interleaved with other output results. In another implementation, a particular exception is selected that represents the multiple exceptions. The selected one particular exception is then thrown.

Concurrent handling of exceptions in received aggregate exception structure with supplied exception handlers and marking handled exceptions

Various technologies and techniques are disclosed for providing concurrent exception handling. Exceptions that occur in concurrent workers are caught. The caught exceptions are then forwarded from the concurrent workers to a coordination worker. The caught exceptions are finally aggregated into an aggregation structure, such as an aggregate exception object. This aggregation structure is rethrown and the individual caught exceptions may then be handled at a proper time.

Concurrent exception handling using an aggregated exception structure

A profiler manager may attach and detach profilers from a running application. A profiler may be detached through a two step process where the profiler is sealed from communicating with the running application, then an evacuation step where the application is able to complete any responses that are pending. While the profiler is in the evacuation phase, another profiler may be attached to the application. Messages to the evacuating profiler may be captured and directed to the proper profiler.

Profiler management

A system and method for mitigating problems associated with automatic execution of initialization code is provided. The system includes an initialization method activator that can call a class initialization method at a pre-determined execution point. The system also includes a deadlock analyzer that can determine whether calling the initialization method will create a deadlock, and, if a deadlock is detected that can resolve such a deadlock. The system also includes a semantic analyzing component that can analyze a semantic type associated with the initialization method and a domain uniqueness analyzer that can analyze the uniqueness of the domain with which the class will interact, to facilitate determining where to place code that will check whether a class is initialized, and if the class is not initialized that will invoke the class initializing method.

Class initialization method semantics

A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.

Declarative pinning

Growing community of inventors

Kirkland, WA, United States of America

Vance Palmer Morrison