Microsoft Technology Licensing, LLC

David William Shoots

Harikrishna Menon Ajith Kumar

Carlos Pessoa

Pankaj Kachrulal Sarda

Steven Brix Kirbach

Ahmad Khalifa Eesa Ahmad

Max Williams Brister

Fabian Toader

Unnikrishnan Ravindranathan

Christophe Philippona

Daniel Zilcsak

Developers receive automatically designated property change events which caused invalidation of a rendered frame. Some embodiments control display invalidation in part by identifying higher-level frame bounding events in an execution trace, and applying at least one display invalidation constituency filter to lower-level thread events within a frame creation period, thereby obtaining a display invalidation constituency sequence of one or more display invalidation events. The sequence may include a layout property change event and/or a render property change event which invalidated the frame. An initial part of the sequence is designated as a display frame creation cause. Displayed frame invalidation is controlled by altering the display invalidation constituency, e.g., by manual or automated layout/render property change event elimination or event sequence location change, by a reduction in computational resource usage (e.g., memory usage, graphics processor chip usage), and/or by a reduction in thread execution time which provides a faster frame rate.

Frame invalidation control with causality attribution

Technologies are disclosed for providing developers with rule output indicating that issues are or may be present in the code they are developing. Such rule output can include or be accompanied by guidelines and/or best practices structured to aid developers in becoming aware of and resolving the issues. In one example, this involves identifying the issues, making available a mechanism of further investigating the issues, and providing best practices and/or recommended solutions for the issues. Finally, the technologies disclosed may automate application of the recommended solutions. The notifications and accompanying guidance/automation and the like can be provided at design-time, compile-time, and/or run-time with the notifications and accompanying guidance/automation integrated into editors, compilers, debuggers, and other development environment tools providing true real-time and in situ development experience.

System for monitoring and reporting performance and correctness issues across design, compile and runtime

Embodiments profile usage of memory and other resource. Stack traces have lifespans, resource impacts, and constituent call chains. Aggregation unifies shared call chains and sums resource impacts after assigning traces to snapshot sets based on trace lifespans and user-defined snapshot request timestamps. Traces are assigned using either active aggregation or precursor aggregation. Traces spanning a snapshot request may be split. A sampled resource trace lifespan begins when the resource is sampled and ends at the next snapshot request. An allocated resource trace lifespan begins when a portion of the resource is allocated and ends when the allocated portion is freed. Resource portions not yet freed are implicitly freed when program execution ends. Call chain interval resource impact aggregation performed with multiple snapshot requests and stack trace sets creates snapshot aggregations. Two aggregations are differenced by subtracting the summed call chain resource impacts of one aggregation from those of another aggregation.

Call chain interval resource impact unification

A performance state machine is controlled in part by identifying notifications from an execution trace of an application program, through rapid automatic comparison of trace events to notification events for notification categories. Some notification categories include application startup, page outline load, page data load start, page data load finish, page to page transition, application input, window size change, media query, binding update, page background task start, page background task finish, developer-defined scenario start, and developer-defined scenario finish. Notifications may reflect heuristics such as the time from startup to first frame submission. A state is placed in the performance state machine for each identified notification, with aggregate application performance data for each transition between identified notifications. Some performance data categories include network activity, disk activity, memory usage, parse time, frame time, dropped frames, component or overall frame rates, and thread utilization. Timelines and other visual representations aid application performance optimization.

Performance state machine control with aggregation insertion

Embodiments profile usage of memory and other resources. Stack traces have lifespans, resource impacts, and constituent call chains. Aggregation unifies shared call chains and sums resource impacts after assigning traces to snapshot sets based on trace lifespans and user-defined snapshot request timestamps. Traces are assigned using either active aggregation or precursor aggregation. Traces spanning a snapshot request may be split. A sampled resource trace lifespan begins when the resource is sampled and ends at the next snapshot request. An allocated resource trace lifespan begins when a portion of the resource is allocated and ends when the allocated portion is freed. Resource portions not yet freed are implicitly freed when program execution ends. Call chain interval resource impact aggregation performed with multiple snapshot requests and stack trace sets creates snapshot aggregations. Two aggregations are differenced by subtracting the summed call chain resource impacts of one aggregation from those of another aggregation.

Growing community of inventors

Hollis, NH, United States of America

David William Shoots