Microsoft Technology Licensing, LLC

Microsoft Corporation

Alexander Dadiomov

Xinhua Ji

Mayank Agarwal

Hazim Shafi

Dana D Groff

Matthew L Jacobs

Yosseff Levanoni

Richard Douglas Hill

Eric Ledoux

Raphael Renous

Daniel Griffing

Paulo Cesar Sales Janotti

Drake A Campbell

Ben Nesson

James Rapp

David L Detlefs

John Joseph Duffy

Vinod Grover

Timothy Lawrence Harris

Stephen Harris Toub

Michael M Magruder

Martin Abadi

Neil Scott Fishman

James Ernest Johnson

James M Lyon

Weirong Zhu

Lingli Zhang

Craig Andrew Critchley

Krishnan Srinivasan

James Christopher Gray

Vikram Padmakar Bapat

Alexey Kamenev

Yossi Levanoni

Sukhdeep S Sodhi

Erez Haba

Christopher William Dern

Charles E Kindel

Uri Habusha

Ryan A Nowak

Uday S Hedge

William T Colburn

George Essex Englebeck

Jared Robert Van Leeuwen

Richard D Hill

One or more systems and/or techniques for generating an adaptive tree structure for storing event data based upon data density of events are disclosed. In particular, the adaptive tree structure may comprise one or more levels of nodes, where a level may correspond to a resolution of events. Nodes may correspond to particular time spans over which event data was recorded. A node may be designated as a raw node comprising raw events or a summary node comprising summary events based upon the number of events occurring within a time span covered by the node.

Adaptive tree structure for visualizing data

Normalizing time across machines in a distributed system. A method includes obtaining one or more points defining differences in time between machines in the distributed system. Using the points, a determination of one or more time measurement drifts between machines is made. The one or more time measurement drifts indicate changing differences in time over time. One or more traces are collected. Each trace includes one or more events. Each event is correlated to a time stamp from one of the machines in the distributed system. Using the one or more determined time measurement drifts, the time stamps are normalized.

Time synchronization across computers in a distributed system

The present invention extends to methods, systems, and computer program products for linking diagnostic visualizations to regions of application code. Diagnostic visualizations emitted during execution of an application are displayed. The diagnostic visualizations partially represent the abstract objective of the application (e.g., as envisioned by a developer). Diagnostic data for at least one of a plurality of components is displayed. The diagnostic data indicates the performance of the at least one of the plurality of components during execution of the application. The displayed one or more diagnostic visualizations and the displayed diagnostic data is correlated to link the one or more diagnostic visualizations to the at least one of the plurality of components. Linking the one or more diagnostic visualizations to the at least one of the plurality of components can better indicate how the application's behavior reconciles the abstract objective.

Linking diagnostic visualizations to application code

A method of providing a visualization of states of a process includes identifying a set of potential states that can occur during the process and a corresponding set of colors, with each color in the set of colors corresponding to one of the potential states. A fixed ordering is established for the set of colors. A timeline graph including a plurality of colored vertical bars is displayed. Each colored vertical bar corresponds to a time interval of the process and includes at least one color selected from the set of colors based on at least one state occurring during the time interval corresponding to the vertical bar. The plurality of colored vertical bars includes a set of multiple-color vertical bars that each include a plurality of colors appearing in a vertical order based on the fixed ordering.

Visualization of states of a process

The present invention extends to methods, systems, and computer program products for calculating zoom level timeline data. Event aggregators are configured to read execution data from sequentially received input buffers and pre-calculate data chunks for a specified zoom level to create a zoom tree. The density of execution data can be used to determine when pre-calculation is beneficial. In response to a user request, pre-calculated data can be combined with responsively calculated data for presentation to a user. User requests can specify zoom levels and time ranges over which data is to be presented.

Calculating zoom level timeline data

The construction or use of a hierarchical time tree that represents an execution time of a program. To construct the hierarchical time tree, the time frame corresponding to the root node is the execution time during which the plurality of call stack samples were gathered from the program. Beginning at the root node, and proceeding recursively, each node is then populated in a manner that all of the call stacks for a given time period need not be accessed in order to provide a report regarding the given time period.

Dynamic calculation of sample profile reports

The present invention extends to methods, systems, and computer program products for time-based navigation within resource utilization data. A computer system is configured to present resource utilization data representing performance of computer resources. The resource utilization data is displayed on a diagnostic data trace during the execution of the application. The user can select a desired time range and the resource utilization data within the time range will be displayed at other traces. The diagnostic data trace is still presented so that the user can understand the relation between the selected time range and the overall time length. Further, the user can modify the selected time range by change the extents of the selected time range using resizing tool. The resource utilization data within the modified selected time range, similarly, is also displayed along with the diagnostic data trace.

Time-based navigation within resource utilization data

A priority based scheduling system for a server prioritizes multiple tasks that are defined using various constraints, which may include relationships defined between different tasks, performance parameters for each task, and completion constraints. The system may track actual performance of a task and update the performance parameters over time. Some embodiments may include a status monitoring agent that may detect that a monitored network parameter has changed that may cause a scheduled task to be raised or lowered in priority. The system may be used to schedule and execute one time tasks as well as recurring tasks, and may execute those tasks during a rigid or flexible periodic time window. Many of the tasks may be pausable and resumable, and such tasks may be performed in increments over successive time windows.

Priority based scheduling system for server

Transactional memory compatibility type attributes are associated with intermediate language code to specify, for example, that intermediate language code must be run within a transaction, or must not be run within a transaction, or may be run within a transaction. Attributes are automatically produced while generating intermediate language code from annotated source code. Default rules also generate attributes. Tools use attributes to statically or dynamically check for incompatibility between intermediate language code and a transactional memory implementation.

Transactional memory compatibility management

Add-on functions to a software application are made through a single dynamic linked library ('DLL'). After discovering, authenticating, and loading the DLL, the application may inspect the DLL to determine if it contains a function of a predetermined type. If the type is discovered, an object of the type may be instantiated and called. The inspection may evaluate metadata within the DLL to determine the precise characteristics of the function and compare the function to a predetermined type. Based on the authentication as well as the internal inspection of the DLL, extensions to existing software applications may be easily distributed and readily installed in an atomic fashion.

Dynamic linked library add-on features

A transactional memory processing system provides for the integration of transactional memory concepts at the compiler-level into a higher-level traditional transaction processing system. Atomic blocks at the compiler-level can be specified as atomic block transactions and include the features of atomicity and isolation. Actions within this atomic block transaction include the enlistment of resource managers from a repository. The repository can now include a pre-programmed memory resource manager to manage the transactional memory. As in traditional transactions, a commit protocol can be used to determine if the actions are valid and can be exposed outside of the transaction. Unlike traditional transactions, however, the transaction is not necessarily doomed if all of the actions are not validated. Rather, memory conflicts can cause a rollback and re-execution of the atomic block transaction, which can be repeated as long as necessary, until the memory resource manger votes to commit.

Transaction processing in transactional memory

A processing system includes a transactional memory, first and second resource managers, and a transaction manager for a concurrent program having a thread including an atomic transaction having a side-effecting action. The first resource manager is configured to enlist in the atomic transaction and manage a resource related to the side effecting action. The second resource manager is configured to enlist in the atomic transaction and manage the transaction memory. The transaction manager is coupled to the first and second resource managers and manager is configured to receive a vote from the first and second resource managers as to whether to commit the transaction. The side-effecting action is postponed until after the transaction commits or applied along with a compensating action to the side-effecting action.

Transaction processing for side-effecting actions in transactional memory

The present invention extends to methods, systems, and computer program products for using subqueues to enhance local message processing. Messages include queue IDs comprised of a parent portion and a suffix portion. The parent portion identifies a parent queue and the suffix portion identifies a subqueue of the parent queue. Message are logically moved between queues by changing suffix values, such as, for example, between subqueues, between the parent queue and a subqueue, and between a subqueue and the parent queue. Applications can examine messages and route messages to specified subqueues based on message content (including message bodies and headers). Suffix values can be changed in place (e.g., while the message remains physically stored in the queue) so as to preserve message sender identity and to avoid prematurely acknowledging delivery (i.e., no return ACK is generated).

Using subqueues to enhance local message processing

The present invention extends to methods, systems, and computer program products for failed message error recovery using application specific error queues. An application message, a reference to a receive queue that corresponds to a receiving application, and a reference to an application specific error queue specific to a sending application are received from the sending application. The application message is enqueued in a transmission queue. Transfer of the application message to the receive queue is attempted. It is detected that the application message was not delivered to the receiving application due to an error. The application message is moved from the transmission queue to the application specific error queue. The application message and appropriate error information is returned from the application specific error queue to the sending application.

Failed message error recovery using application specific error queues

Growing community of inventors

Redmond, WA, United States of America

Alexander Dadiomov