Microsoft Technology Licensing, LLC

Shawn L Hargreaves

John Mitchell Walker

Paul Lawrence Bleisch

Austin Neil Kinross

Matthew Picioccio

Thomas Lee Davidson

Amar Dinesh Patel

Richard Andrew Meyer

Thomas Wayne Miller, Jr

Adrian Tsai

Boyd Cannon Multerer

Tom Miller

Mel MacMahon

James Bartlett

Robert A Anderson

Michael T Klucher

Josefa M G Nalewabau

Frank F Savage

Josefa M Nalewabau

Damyan Jonathan Pepper

Nicolas Gauvin

Eli J Tayrien

Examples described herein generally relate to generating a visualization of an image. A proprietary structure that specifies ray tracing instructions for generating the image using ray tracing is intercepted from a graphics processing unit (GPU) or a graphics driver. The proprietary structure can be converted, based on assistance information, to a visualization structure for generating the visualization of the image. The visualization of the image can be generated from the visualization structure.

Techniques for generating visualizations of ray tracing images

Examples described herein generally relate to indicating resource utilization by a graphics processing unit (GPU). Data indicating a hierarchy of architectural units for executing processing threads on a GPU can be obtained. An indication of a slot assigned to a collection of threads for executing on the GPU can be received, where the slot is associated with a single instruction multiple data (SIMD) module capable of concurrently executing multiple collections of threads. An architectural unit to which the slot is assigned can be determined based on the data indicating the hierarchy of architectural units. An indication of the architectural unit as executing the collection of threads can be outputted.

Techniques for tracking independent hardware graphics processing unit (GPU) performance

Examples described herein generally relate to reporting faults in a graphics processing unit (GPU). A list of rendering instructions for causing the GPU to render graphics can be captured, and occurrence of a fault in executing the list of rendering instructions can be detected. A portion of the list of rendering instructions can be executed, in isolation from a second portion of the list of rendering instructions, based on detecting occurrence of the fault to identify the fault in the portion of the list of rendering instructions or the second portion of the list of rendering instructions. The portion of the list of rendering instructions or the second portion of the list of rendering instructions can be indicated as causing the fault.

Techniques for detecting faults in rendering graphics

Examples described herein generally relate to modifying operations of a graphics processing unit (GPU) for tracking. An indication of multiple shaders to be executed in rendering an image can be obtained from a command buffer of commands to be provided to the GPU for rendering the image. At least one shader of the multiple shaders can be modified to generate a modified shader that includes a command to log one or more parameters when executing the modified shader. The command buffer can be provided to the GPU for executing the commands for rendering the image including executing the modified shader.

Techniques for modifying graphics processing unit (GPU) operations for tracking in rendering images

Embodiments of the invention rely on simple time measurements to extract rich performance analysis from a graphics program. The invention times the program as it repeatedly executes on a selected platform, while a series of variations are applied to the program with each execution. As a result, without requiring any specific profiling tools for the platform, a developer can analyze and understand the performance characteristics of the program based upon these elapsed time measurements. The program can then be optimized to incorporate variations that improve execution time.

Extracting rich performance analysis from simple time measurements

A set of importers accept a variety of formats of 2D and 3D content (source asset) for computer games in the format created by the artists' authoring tool. The source asset is standardized and normalized and is stored as a strongly typed object in a content object model. An object from the content object model can be deserialized to a file for debugging. The object can be converted to a managed object to which game code can be written. An executable object is generated from the object created during game development automatically.

Transporting and processing foreign data

Systems, methods and computer readable media are disclosed for a trusted proxy to intercept communications between an untrusted computerized gaming system and an online multi-player gaming service that requires games to be trusted, allowing the untrusted computerized gaming system to use the multi-player gaming service. In addition to allowing the untrusted computerized gaming system to use the multi-player gaming service in general, the trusted proxy can also limit the extent of the interaction between the untrusted computerized gaming system and the multi-player gaming service.

Untrusted gaming system access to online gaming service

Mechanisms are disclosed that allow for execution of unsigned content and the securing of resources in a closed system when such unsigned content is executing on the system. For example, an application programming interface is used between an access layer implementing unsigned content and an operating system of the closed system. The application programming interface may have sub-interfaces that correspond to sub-layers of the access layer, including a graphics sub-interface, an audio sub-interface, an input sub-interface, and a storage sub-interface. These sub-interfaces present access calls made by the sub-layers to the protected resources of the closed system. By providing the application programming interface, unsigned content, e.g., video games can run on a closed system that is typically designed to run only signed content.

Programming framework for closed systems

Mechanisms allow for execution of unsigned managed code graphic resource call in a closed system when such unsigned content is executing on the system. For example, a managed code graphic resource device is used between an application running unsigned content and a supervisor mode graphic resource device. A managed mode graphics device validates graphic resource calls made by the application. A managed mode graphics device manages resource calls by differentiating between calls that may be made directly to the supervisor mode graphics device, calls that may be pipelined for later action, and calls that may be made to an intermediate device.

Systems, methods and computer readable media are disclosed for an overlaying requester to send graphics commands to a game connected to the overlaying requester via a dummy graphics application programming interface (API) object that the game will render over normal game-play graphics. In addition to allowing the overlaying requester to send graphics commands to the game in general, the dummy graphics API object can also limit the extent of the interaction between the overlaying requester and the computerized gaming system.

Proxy direct 3-D device and remote rendering

Mechanisms are disclosed that allow for platform abstraction of a computing platform using a programming framework. The programming framework allows application programs to interact with different platforms in an identical manner by abstracting the platform. The application uses identical instructions to the programming framework across different platforms, with the programming framework modifying the instructions to fit platform specific requirements. The programming framework also emulates platform specific expected application behavior on behalf of the application. The programming framework may also provide an additional layer of security for the platform, limiting the access of the application program.

A data provider application programming interface (API) is configured for use with a game content editing application. An asset relationship management file, which is generated with the data provider API, includes information such as relationship references and annotations and is updated by the data provider API when a digital asset is edited. The asset relationship management file is then stored in a data store. An asset relationship graph is generated, based on the asset relationship management file in the data store. The asset relationship graph includes asset graph nodes that map dependency relationships between asset files. A graph API is also described. The graph API is configured for accessing the relationship graph through a server process to expose dependency relationships and annotations to a client process, such as an application. Thus, the effect of changes to one asset on other assets can readily be evaluated.

Growing community of inventors

Redmond, WA, United States of America

Shawn L Hargreaves