Microsoft Technology Licensing, LLC

Cole Brooking

Ivan Nevraev

J Andrew Goossen

Eric Christoffersen

Jason Strayer

Pragyana K Mishra

Nishant Dani

Pengpeng Wang

Brian Bo Rasmussen

Manjula Ananthnarayanan Iyer

Jason Matthew Gould

Michael Alan Dougherty

James Andrew Goossen

Aaron Rodriguez Hernandez

Nihar Mohapatra

Parikshit Gopal Narkhede

Veena K Malwankar

To optimize the compilation of shaders for execution within an application, a computer system discovers the context in which the shaders are executed. The application is compiled and executed on a target platform. Snapshots of the application during execution are captured. A snapshot includes data and commands passed between the central processing unit and the graphics processing unit of the target platform to generate a single frame of graphics data. The shaders used in these snapshots are identified. These shaders are compiled with a number of different permutations of available compiler options, resulting in sets of differently compiled shaders. The snapshot is re-executed with the sets of differently compiled shaders, and performance is measured. The set of compiler options that results in compiled shaders providing better performance can be used as the set of compilation parameters for the set of shaders for this application.

Optimizing compilation of shaders

Examples described herein generally relate to capturing and executing graphics processing operations. A memory trap function can be activated to cause a graphics processing unit (GPU) to report memory accesses in executing graphics processing operations. Based on activating the memory trap function and for each of a sequence of executed graphics processing operations executed by the GPU, a sequence of memory accessing commands and associated portions of memory modified based on executing the sequence of executed graphics processing operations can be received. Each of the sequence of multiple memory accessing commands and associated portions of memory can be stored and provided to the GPU to emulate re-executing of the sequence of executed graphics processing operations by the GPU.

Techniques for capturing and executing graphics processing operations

Methods and devices for testing graphics hardware may include reading content of a selected capture file from a plurality of capture files. The methods and devices may include transferring content from the selected capture file to an emulator memory of an emulator separate from the computer device. The methods and devices may include executing at least one pseudo central processing unit (pseudo CPU) operation to coordinate the execution of work on a graphics processing unit (GPU) of the emulator using the content from the selected capture file to test the GPU. The methods and devices may include receiving and store rendered image content from the emulator when the work is completed.

Execution of graphic workloads on a simulated hardware environment

Examples described herein generally relate to reporting memory resource access by a graphics processing unit (GPU). A list of memory resources allocated for the GPU can be received by a memory tracking application. An indication of memory resource utilization based on the list of memory resources can be displayed on an interface. The memory tracking application can also receive, from the GPU, multiple indications that one or more of the memory resources allocated for the GPU are accessed, and can update the indication of memory resource utilization based at least in part on the multiple indications.

Techniques for tracking graphics processing resource utilization

The techniques and systems described herein are directed to capturing commands in a multi-engine graphics processing unit (GPU). Captured commands can be played back by a developer to optimize software, hardware, and drivers. To accurately capture commands and memory associated with the commands during execution, dependencies between command buffer segments associated with the various GPU engines may be determined and used to divide a command buffer segment into atomic elements (which may also be referred to as seglets). Command buffer segments are analyzed to identify synchronization commands, which may represent a point in a command buffer segment that relies on an operation to be completed in another command buffer segment. The command buffer segment can be recursively divided into seglets based on the synchronization commands. The resulting seglets represent command segments that, upon execution, operate without synchronization interference from other command buffer segments.

Capturing commands in a multi-engine graphics processing unit

The placement of one animated element in a virtualized three-dimensional environment can be accomplished with reference to a second animated element and a vector field derived from the relationship thereof. If the first animated element is 'inside' the second animated element after the second one was moved to a new animation frame, an existing vector field can be calculated for the region where it is 'inside'. The vector field can comprise vectors that can have a direction and magnitude commensurate with the initial velocity and direction required to move the first animated element back outside of the second one. Movement of the first animated element can then be simulated in accordance with the vector field and afterwards a determination can be made whether any portion still remains inside. Such an iterative process can move and place the first animation element prior to the next move of the second animation element.

Placement of animated elements using vector fields

Sketches, notes and 2D computer drawings of a designed garment can be input into a computing device. The computing device can apply optical character recognition, shape inference, figure recognition, domain intelligence and inferred knowledge to automatically generate a garment construction specification from the input information. The garment construction specification can include a detailed description of each component of the garment, followed by step-by-step instructions, such as could be consumed by a computer-controlled device, regarding the joining of the components to create the garment. A virtual garment generation mechanism can create a 3D rendering of the garment by constructing each component and then joining them together to act as a single 3D piece. Material behavioral properties can also be applied to the 3D rendering. User feedback regarding the 3D rendering can be utilized to create a modified garment construction specification which can ultimately, when approved, be provided to a garment manufacturer.

Growing community of inventors

Woodinville, WA, United States of America

Cole Brooking