Microsoft Technology Licensing, LLC

John Lee Rapp

Andrew L Bliss

Michael Vincent Oneppo

Craig C Peeper

Mark M Lacey

Yosseff Levanoni

Peter-Pike Johannes Sloan

Weirong Zhu

Lingli Zhang

Samuel Z Glassenberg

Daniel Kurt Baker

Paul Maybee

Eric Stanfield Leese

Maria K Blees

Shai Hinitz

Allocation of memory registers for shaders by a processor is described herein. For each shader, registers are allocated based on the shader's level of complexity. Simpler shader instances are restricted to a smaller number of memory registers. More complex shader instances are allotted more registers. To do so, developers' high level shading level (HLSL) language includes template classes of shaders that can later be replaced by complex or simple versions of the shader. The HLSL is converted to bytecode that can be used to rasterize pixels on a computing device.

Dynamic subroutine linkage optimizing shader performance

A computer-implemented method, computer-readable media, and a computerized system to track and detect data hazards are provided. The computerized system includes processors configured to execute instructions associated with a multithreaded program. The computerized system allocates memory for the multithreaded program and creates threads for execution on the processors. The memory may include a reserved area for tracking information. The threads access the allocated memory in accordance with the multithreaded program and the memory including the tracking information is updated based on the threads' memory access. In turn, the processors generate notifications of data hazard based on the tracking information stored in the allocated memory.

Detecting memory hazards in parallel computing

The present invention extends to methods, systems, and computer program products for emulating pointers. Pointers can be emulated by replacing the pointers with a &#x3c;variable#, offset&#x3e; pair and replacing each dereference site with a switch on the tag and a switch body that executes the emulated pointer access on the corresponding variable the pointer points to. Data flow optimizations can be used to reduce the number of switches and/or reduce the number of cases which need be considered at each emulated pointer access sites.

Emulating pointers

The debugging of a program in a data parallel environment. A connection is established between a debugging module and a process of the data parallel environment. The connection causes the data parallel environment to notify the debugging module of certain events as they occur in the execution of the process. Upon notification of such an event, the process execution is paused, and the debugging module may query the data parallel environment for information regarding the process at the device independent virtual machine layer. Upon completion of this querying, the process may then resume execution. This may occur repeatedly if multiple events are encountered.

Debugging in data parallel computations

The present invention extends to methods, systems, and computer program products for reconstructing program control flow. Embodiments include implementing or morphing a control flow graph ('CFG') into an arbitrary loop structure to reconstruct (preserve) control flow from original source code. Loop structures can be optimized and can adhere to target platform constraints. In some embodiments, C++ source code (a first higher level format) is translated into a CFG (a lower level format). The CFG is then translated into High Level Shader Language ('HLSL') source code (a second different higher level format) for subsequent compilation into SLSL bytecode (that can then be executed at a Graphical Processing Unit (&#x201c;GPU&#x201d;)). The control flow from the C++ source code is preserved in the HLSL source code.

Reconstructing program control flow

Systems, methods, and computer storage media having computer-executable instructions embodied thereon determine whether an output value of a dependency graph has a particular characteristic. In one embodiment, to make this determination, a dependency graph is generated that illustrates external and internal nodes, in addition to their dependency to one another. External nodes, or those nodes that do not depend on other nodes, are analyzed to determine whether they have a particular characteristic. Depending on the operation associated with the characteristic, it may then be determined whether the output value of the dependency graph also has that characteristic.

Characteristic determination for an output node

In a technique for rendering non-linear BRDFs that are stable in both the temporal and spatial domains, without serious interruption to the content creation pipeline used in most games, non-linear content is linearized by rendering in texture space at a fixed resolution. A MIP-map chain is calculated from this texture. The complete MIP-map chain is used for rendering on a display device. Low resolution reflectance parameters are used to approximate the highest resolution reflectance parameters as the object becomes smaller on the display device. The low resolution reflectance parameters are calculated using non linear fitting techniques.

Growing community of inventors

Seattle, WA, United States of America

John Lee Rapp