One or more embodiments generally relate to a single-instruction multiple data/thread (SIMD/T) processing environments and, in particular, to reducing execution of redundant threads for reducing resource usage in a SIMD/T processing environment.
In a SIMD/T execution model, multiple different physical threads (SIMD channels) execute the same code with different input data. This execution model is widely used in graphical processing unit (GPU) hardware (HW) both for graphics and, with the increase of general-purpose computing on graphics processing units (GPGPU) programming, for many non-graphical applications.
One or more embodiments generally relate to reducing execution of redundant threads for reducing resource usage in a SIMD/T processing environment. In one embodiment, a method provides for reducing execution of redundant threads in a processing environment and includes detecting threads that include redundant work among many different threads. Multiple threads from the detected threads are grouped into one or more thread clusters based on determining same thread computation results. Execution of all but a particular one thread in each of the one or more thread clusters is suppressed. The particular one thread in each of the one or more thread clusters is executed. Results determined from execution of the particular one thread in each of the one or more thread clusters are broadcasted to other threads in each of the one or more thread clusters.
In one embodiment, a non-transitory computer-readable medium having instructions which when executed on a computer perform a method comprising: detecting threads that include redundant work among a plurality of different threads. Multiple threads from the detected threads are grouped into one or more thread clusters based on determining same thread computation results. Execution of all but a particular one thread in each of the one or more thread clusters is suppressed. The particular one thread in each of the one or more thread clusters is executed. Results determined from execution of the particular one thread in each of the one or more thread clusters are broadcasted to other threads in each of the one or more thread clusters.
In one embodiment, a graphics processor for an electronic device comprises: one or more processing elements coupled to a memory device. In one embodiment, the one or more processing elements: detect threads that include redundant work among a plurality of different threads. Multiple threads from the detected threads are grouped into one or more physical thread clusters based on determining same thread computation results. Execution of all but a particular one thread in each of the one or more thread clusters are suppressed. The particular one thread in each of the one or more thread clusters is executed. Results determined from execution of the particular one thread in each of the one or more thread clusters are broadcasted to other threads in each of the one or more thread clusters.
These and other aspects and advantages of one or more embodiments will become apparent from the following detailed description, which, when taken in conjunction with the drawings, illustrate by way of example the principles of the one or more embodiments.
For a fuller understanding of the nature and advantages of the embodiments, as well as a preferred mode of use, reference should be made to the following detailed description read in conjunction with the accompanying drawings, in which:
The following description is made for the purpose of illustrating the general principles of one or more embodiments and is not meant to limit the inventive concepts claimed herein. Further, particular features described herein can be used in combination with other described features in each of the various possible combinations and permutations. Unless otherwise specifically defined herein, all terms are to be given their broadest possible interpretation including meanings implied from the specification as well as meanings understood by those skilled in the art and/or as defined in dictionaries, treatises, etc.
One or more embodiments generally relate to reducing execution of redundant threads for reducing resource usage in a SIMD/T processing environment. One or more embodiments may organize multiple instructions into schedulable structure referred to as a trace. A trace is a region of code that contains a number of instructions and the following properties: a trace will not begin execution until specified events have occurred; a trace will not begin execution until all required resources are available; and a trace once entered into execution, executes to completion. The trace bundles a plurality of instructions into a single schedulable unit. The trace contains a header (e.g., a trace header). The trace header includes a list of resources that the multiple instructions in the trace need or require.
In one example the trace header is organized to simplify matching of resource requests to available resources, and the SIMT scheduling process. Because the trace runs to completion, the data-path may be augmented with a small low overhead tunnel register file. The tunnel register file does not persist across trace boundaries and thus may be considered inexpensive with respect to context switching and SIMT scheduling.
In one embodiment, a method provides for reducing execution of redundant threads in a processing environment and includes detecting threads that include redundant work among many different threads. Multiple threads from the detected threads are grouped into one or more thread clusters based on determining same thread computation results. Execution of all but a particular one thread in each of the one or more thread clusters is suppressed. The particular one thread in each of the one or more thread clusters is executed. Results determined from execution of the particular one thread in each of the one or more thread clusters are broadcasted to other threads in each of the one or more thread clusters.
Any suitable circuitry, device, system or combination of these (e.g., a wireless communications infrastructure including communications towers and telecommunications servers) operative to create a communications network may be used to create communications network 110. Communications network 110 may be capable of providing communications using any suitable communications protocol. In some embodiments, communications network 110 may support, for example, traditional telephone lines, cable television, Wi-Fi (e.g., an IEEE 802.11 protocol), BLUETOOTH®, high frequency systems (e.g., 900 MHz, 2.4 GHz, and 5.6 GHz communication systems), infrared, other relatively localized wireless communication protocol, or any combination thereof. In some embodiments, the communications network 110 may support protocols used by wireless and cellular phones and personal email devices (e.g., a BLACKBERRY®). Such protocols may include, for example, GSM, GSM plus EDGE, CDMA, quadband, and other cellular protocols. In another example, a long range communications protocol can include Wi-Fi and protocols for placing or receiving calls using VOIP, LAN, WAN, or other TCP-IP based communication protocols. The transmitting device 12 and receiving device 11, when located within communications network 110, may communicate over a bidirectional communication path such as path 13, or over two unidirectional communication paths. Both the transmitting device 12 and receiving device 11 may be capable of initiating a communications operation and receiving an initiated communications operation.
The transmitting device 12 and receiving device 11 may include any suitable device for sending and receiving communications operations. For example, the transmitting device 12 and receiving device 11 may include a mobile telephone devices, television systems, cameras, camcorders, a device with audio video capabilities, tablets, wearable devices (e.g., wearable wrist or watch type devices, pendants, head-worn devices, pins, etc.), and any other device capable of communicating wirelessly (with or without the aid of a wireless-enabling accessory system) or via wired pathways (e.g., using traditional telephone wires). The communications operations may include any suitable form of communications, including for example, voice communications (e.g., telephone calls), data communications (e.g., e-mails, text messages, media messages), video communication, or combinations of these (e.g., video conferences).
In one embodiment, all of the applications employed by the audio output 123, the display 121, input mechanism 124, communications circuitry 125, and the microphone 122 may be interconnected and managed by control circuitry 126. In one example, a handheld music player capable of transmitting music to other tuning devices may be incorporated into the electronics device 120.
In one embodiment, the audio output 123 may include any suitable audio component for providing audio to the user of electronics device 120. For example, audio output 123 may include one or more speakers (e.g., mono or stereo speakers) built into the electronics device 120. In some embodiments, the audio output 123 may include an audio component that is remotely coupled to the electronics device 120. For example, the audio output 123 may include a headset, headphones, or earbuds that may be coupled to communications device with a wire (e.g., coupled to electronics device 120 with a jack) or wirelessly (e.g., BLUETOOTH® headphones or a BLUETOOTH® headset).
In one embodiment, the display 121 may include any suitable screen or projection system for providing a display visible to the user. For example, display 121 may include a screen (e.g., an LCD screen) that is incorporated in the electronics device 120. As another example, display 121 may include a movable display or a projecting system for providing a display of content on a surface remote from electronics device 120 (e.g., a video projector). Display 121 may be operative to display content (e.g., information regarding communications operations or information regarding available media selections) under the direction of control circuitry 126.
In one embodiment, input mechanism 124 may be any suitable mechanism or user interface for providing user inputs or instructions to electronics device 120. Input mechanism 124 may take a variety of forms, such as a button, keypad, dial, a click wheel, or a touch screen. The input mechanism 124 may include a multi-touch screen.
In one embodiment, communications circuitry 125 may be any suitable communications circuitry operative to connect to a communications network (e.g., communications network 110,
In some embodiments, communications circuitry 125 may be operative to create a communications network using any suitable communications protocol. For example, communications circuitry 125 may create a short-range communications network using a short-range communications protocol to connect to other communications devices. For example, communications circuitry 125 may be operative to create a local communications network using the BLUETOOTH® protocol to couple the electronics device 120 with a BLUETOOTH® headset.
In one embodiment, control circuitry 126 may be operative to control the operations and performance of the electronics device 120. Control circuitry 126 may include, for example, a processor, a bus (e.g., for sending instructions to the other components of the electronics device 120), memory, storage, or any other suitable component for controlling the operations of the electronics device 120. In some embodiments, a processor may drive the display and process inputs received from the user interface. The memory and storage may include, for example, cache, Flash memory, ROM, and/or RAM/DRAM. In some embodiments, memory may be specifically dedicated to storing firmware (e.g., for device applications such as an operating system, user interface functions, and processor functions). In some embodiments, memory may be operative to store information related to other devices with which the electronics device 120 performs communications operations (e.g., saving contact information related to communications operations or storing information related to different media types and media items selected by the user).
In one embodiment, the control circuitry 126 may be operative to perform the operations of one or more applications implemented on the electronics device 120. Any suitable number or type of applications may be implemented. Although the following discussion will enumerate different applications, it will be understood that some or all of the applications may be combined into one or more applications. For example, the electronics device 120 may include an automatic speech recognition (ASR) application, a dialog application, a map application, a media application (e.g., QuickTime, MobileMusic.app, or MobileVideo.app), social networking applications (e.g., FACEBOOK®, TWITTER®, etc.), an Internet browsing application, etc. In some embodiments, the electronics device 120 may include one or multiple applications operative to perform communications operations. For example, the electronics device 120 may include a messaging application, a mail application, a voicemail application, an instant messaging application (e.g., for chatting), a videoconferencing application, a fax application, or any other suitable application for performing any suitable communications operation.
In some embodiments, the electronics device 120 may include a microphone 122. For example, electronics device 120 may include microphone 122 to allow the user to transmit audio (e.g., voice audio) for speech control and navigation of applications 1-N 127, during a communications operation or as a means of establishing a communications operation or as an alternative to using a physical user interface. The microphone 122 may be incorporated in the electronics device 120, or may be remotely coupled to the electronics device 120. For example, the microphone 122 may be incorporated in wired headphones, the microphone 122 may be incorporated in a wireless headset, the microphone 122 may be incorporated in a remote control device, etc.
In one embodiment, the camera interface 128 comprises one or more camera devices that include functionality for capturing still and video images, editing functionality, communication interoperability for sending, sharing, etc. photos/videos, etc.
In one embodiment, the GPU 129 comprises processes and/or programs for processing images and portions of images for rendering on the display 121 (e.g., 2D or 3D images, High definition (HD), ultra-HD (UHD), etc.). In one or more embodiments, the GPU 129 may comprise GPU hardware and memory (e.g., a unified heap architecture (UHA) 410 (
In one embodiment, the electronics device 120 may include any other component suitable for performing a communications operation. For example, the electronics device 120 may include a power supply, ports, or interfaces for coupling to a host device, a secondary input mechanism (e.g., an ON/OFF switch), or any other suitable component.
In one example, a number of work units 305 are bound into a thread and then a number of threads are bound together to execute a shader <program> into a structure referred to as a WARP. A WARP binds a multiplicity of work units 305 into a single point of control. In one example embodiment, the WARP may contain up to 32 threads, and a compiler of a GPU (e.g., part of the GPU 129,
In one example, a thread is a point of control within a WARP. Each thread is associated with a <thread> Register File. In one example, a thread may be allocated as few as 8 and as many as 256 registers with 8 register granularity. The WARP carries a register base address which relocates instruction register specifiers into Register File addresses. The register file 420 (
In one example, a 2-bit WARP braiding field identifies the mode of operation of the threads within the WARP. The braiding enables the compiler of the GPU to produce optimal codes when shader programs utilize half precision and quarter precision instructions. The instructions compute 2 or 4 units of work 305 in a single instruction per thread when braided. In one example, the units of work 305 are governed by an execution mask, one bit of each mask governs a unique unit of work over the WARP. In one example, each instruction in a shader <program> identifies the associated unit of work 305 so that it may be properly governed. The execution mask may be manipulated to effect predication and control transfer. In one example, a simple code sequence performs most of the manipulation with compares instructions with label instructions.
A WARP executes instructions on behalf of all bound threads in such a way that each instruction sees the results of the previous instruction and may use such as operands immediately via forwarding or with some delay by utilizing a tunnel file. In one example, a trace 650 (
In one example, a trace 650 (
In one example, an Idle WARP may be assigned work units 305, assigned a shader program, and allocated a Register File 420 (
In one example, a WARP waits at a trace header 670 (
In one example, after the WARP is scheduled, the WARP scheduler preloads the Loop Buffer 410 (
The WARP scheduler keeps track of which traces 650 are loaded into the Loop Buffer 410 and skips the installation if the trace 650 is already present. In one example, the WARP scheduler prioritizes WARPs pending on the same trace 650 over WARPs pending on a trace 650 yet to be loaded. A WARP may be configured to perform several units of work 305. In one example, the WARP may begin interpolation and texture accesses prior to the start of the pixel shader program. The register file allocation may be deferred until these computations are ready to deliver values to the register file 400 (
The FMAD units perform single precision floating point arithmetic instructions and are instrumental in μCode implementing the transcendental instructions. The Integer unit performs most integer arithmetic, logic operations, and memory address calculations. The BIT manipulation unit performs bit manipulation operations. In one example, pipeline time flows strictly downward except for the two forwarding paths back to the computation unit input multiplexers. The structures at the top of the processing element 400 are the same PDP SRAM components as the structures at the bottom of the processing element 400. In one example, the upper PDP SRAM components are used to read operands and deliver them into computation, while the lower PDP SRAM components are used to write computed values back into the register file 420.
In one example, for the processing element 400 only four operand flip-flops may satisfy the needs of the collectors. In one example embodiment, both normal sequencing {Single Precision, Half Precision and Quarter Precision} and special functional units (SFU) sequencing {Double Precision and certain Integer instructions} may be satisfied by accessing the SRAMs slightly differently. In one example, the registers are used in even-odd pairs for the first two accesses and in even-even and odd-odd pairs on the second set of accesses, which complicates the control but saves the number of required multiplexors.
In one example, the shader header 610 contains a trace count 611 of the number of traces 620-621, the register count 612 of the number of registers per thread, braid control information 615, and a Fixed Function bit 613. Immediately following the shader header 610 is the Active Search Table 616 that includes a number of traces divided by 32 of an Activating Search Optimizer 616.
In one example, the braid specifier of the braid control information 615 is used by the fixed function units in depositing a number of work units 305 (
The Active Search Optimizer tables may only be used in shaders with Forward Branching, CALLs and RETurns, and indirect Jumping. In one example, shaders 600 without these features may omit the tables by clearing the A bit 614 in the shader header 610. In one example, most shaders 610 are small enough such that these tables represent essentially no overhead. In one example, when the Fixed Function Specifier bit 613 (F) is set, the first trace 620-621 in a shader 600 (i.e., trace number 0 or Trace 0) contains instructions for fixed function units. These instructions run autonomously and potentially concurrently with WARP execution. In one example, if the F bit 613 is not set, then trace 0 is the first trace 620-621 to be executed by the shader program.
In one example, there are a number of Trace Pointers in the trace pointer array 617 once a particular trace 620-621 is identified by number. The trace pointer is used to access instructions over a 36-bit address space. The value in the pointer is shifted up by 4 bits (4 bits corresponds to 32-Byte cache lines and a 36-bit address space, 5 bits corresponds to 64-Byte cache lines and a 37-bit address space) to become the byte address of the instruction. In one example, shader threads receive an input data set, and compute an output data set.
In one example, another field in the shader header 610 includes data used to configure the Graphics Pipeline (e.g., graphics pipeline 1000,
In one example, when a Graphics Pipeline 1000 (
The trace header 670 and all instructions 660-661 are 64-bits in size and begin on a cache line boundary. In one example, the trace header 670 contains bit vectors used to represent the outstanding events that must occur prior to this WARP being <re>scheduled. The trace header 670 includes fields for 8-outstanding memory references 679, 8-outstanding texture references 678, and 8-outstanding Interpolation references (IPA) 677. In one example, another 8-bit field exists for Texture Buffer Done (TBD) 672. The trace header 670 also contains field descriptors of the amount of buffer space required prior to this WARP being scheduled. In one example, the Mem field 676 describes how many memory references must be available in the Memory Address Buffer prior to scheduling the WARP. The TCB field 675 describes how many Texture Coordinates must be allocated in the Texture Coordinate Buffer prior to schedule. The TB field 674 describes the persistence of the TCB allocation, and the IP field 673 specifies the number of IPA requests (IPA is mainly Push Mode, the alternative is to send (Pull) Page Table Entries to the processing element 400 (
In one example, the number of instructions 671 in a trace 650 is limited to the size of the Loop Buffer 410 (
In one example, as a trace 650 executes, a number of outstanding events are recorded. The trace header 670 of the subsequent trace contains a bit-vector of outstanding events that must have become resolved prior to scheduling the WARP on the subsequent trace. In one example, this means WARPs are not scheduled into execution until all required outstanding results have been performed. This also means that the shader compiler may decide that some of the outstanding events are not needed in order to execute the subsequent trace.
In one example, as instructions 660-661 are decoded into the Loop Buffer 410 (
In one example, if the F bit 613 (
In one example, a GPU combines threads in groups of limited sizes called WARPs. When the GPU executes a trace it applies the code given in the trace body to all active threads in the WARP that need to execute this code. In one example, consider a WARP with 32 threads that needs to execute a trace with a set of input registers {R0, R1, R2, R3}. In this example, assume that this trace computes a set of output registers {R0, R1} by executing N instructions that do not depend on values computed by other threads. Assume that for threads t0, t1, t2, t3, t4, t5 in some warp the following holds true:
R0(t0)=R0(t1)=R0(t2)=R0(t3)=R0(t4)=R0(t5)
R1(t0)=R1(t1)=R1(t2)=R1(t3)=R1(t4)=R1(t5)
R2(t0)=R2(t1)=R2(t2)=R2(t3)=R2(t4)=R2(t5)
R3(t0)=R3(t1)=R3(t2)=R3(t3)=R3(t4)=R3(t5).
In one example, presume that for threads t20, t21, t22, t23 in the same warp it is also true that:
R0(t20)=R0(t21)=R0(t22)=R0(t23)
R1(t20)=R1(t21)=R1(t22)=R1(t23)
R2(t20)=R2(t21)=R2(t22)=R2(t23)
R3(t20)=R3(t21)=R3(t22)=R3(t23).
Additionally, assume that no other pair of threads has exactly the same set of values in their respective R0, R1, R2, R3 registers. In this example, while executing this trace the following three clusters of threads comprise: thread cluster 815: {t0, t1, t2, t3, t4, t5}, separate individual thread clusters: {t6} {t7} {t8} {t9} {t10} {t11} {t12} {t13} {t14} {t15} {t16} {t17} {t18} {t19}, thread cluster 825: {t20, t21, t22, t23}, and separate individual thread clusters: {t24} {t25} {t26} {t27} {t28} {t29} {t30} {t31}. In one embodiment, there is no reason to execute all of threads in thread cluster 815 {t0, t1, t2, t3, t4, t5} as it is sufficient to execute just t0810 and then broadcast the output registers (in this example, R0 and R1) to corresponding R0 and R1 registers in threads t1, t2, t3, t4, t5.
In one embodiment, while thread t0810 executes trace code, threads t1, t2, t3, t4 and t5 are suppressed, i.e. clock-gated-off. In one example, the thread that will actually execute the code is referred to as a “leader thread” or simply “cluster leader.” All other thread members of the cluster are referred to as follower threads. In this example, t0810 is cluster leader while t1, t2, t3, t4 and t5 are follower threads. Similarly, given the thread cluster 825 of {t20, t21, t22, t23} only thread t20820 (the cluster leader) is executed and then the computation results are broadcast from the output registers to the follower threads {t21, t22, t23}. In one or more embodiments, by not executing N instructions (N being a positive integer) for all cluster threads but one (i.e., the cluster leader thread) in each thread cluster, and then broadcasting the results to the follower threads, a power savings is achieved by reducing execution of multiple threads in a thread cluster.
In one embodiment, the choice of cluster leader is quite arbitrary, in fact since all threads in a thread cluster will compute exactly the same set of values, any thread in a thread cluster may be considered to be the cluster leader. In one example, for simplicity the leader thread may always be chosen as a cluster member with minimal thread ID. Though thread adjacency in general is not required, putting additional restrictions on thread adjacency in a cluster may simplify HW implementation.
In one embodiment, in order to implement the general approach described above HW needs should perform as follows: given a trace input register map provided by a compiler—find thread clusters, and given a trace output register map provided by a compiler—implement a broadcast of computed values. In one example, the compiler is specialized to provide a cost/benefit analysis and mark certain traces as clusterization candidates. In one example, if a number of instructions in a trace (and thus potential power savings) is relatively small, the compiler may choose not to mark such a trace as a candidate for described optimization.
In general, the HW implementation to support this redundancy detection and elimination scheme might be quite costly as the HW has to execute clustering decisions by reading registers from different threads and implement a hash-table with following pair-wise compares to avoid false positives. In one embodiment, for implementation efficiency a simplified version of this approach may be implemented as follows: instead of making thread clusterization decisions per each candidate trace marked by the compiler, an “all-or-none” version of the same concept may be implemented that requires a much simpler HW infrastructure support. In one example, the identity of inputs for the whole program may be detected for avoiding repetitive actions on finding thread clusters. In one embodiment, if the whole program does not explicitly depend on thread IDs and does not have any instructions that may affect the results computed by other threads, it should still be expected that identical input values will result in identical outputs computed by the whole program. In this case only true program outputs are broadcasted, and it will not be necessary to broadcast intermediate values because all follower threads will be suppressed for the whole execution.
In one example, the pipeline 1000 includes a 256-bit result plus 32-bits enable bus. The bus serves to deliver results to the next stage of the graphics pipeline 1000 through the EMIT unit, to deliver addresses to the Load Store unit, to deliver texture coordinates to the Texture Coordinate Buffer, and to deliver offset data to the interpolator for interpolation. In one example, the pipeline 1000 includes a 256-bit Load plus a 32-bit enable bus. The enable bus serves to deliver Load data, Texture results, Interpolation results, and Initialization data into the register file 420. Attached to the enable bus, and running two cycles earlier is a Load address bus which delivers the 9-bit register address to the Loop Buffer 410 and 32-write enable bits to the register file 420.
In one example, the pipeline 1000 includes a 256-bit Store Data plus a 32-bit enable bus. The enable bus delivers register read data to the Load Store Unit. In one example, attached to the enable bus and running two cycles earlier is the store address bus. The protocol on the enable bus is to send the address on the pipeline beat, two cycles later there will be a signal indicating if data will be arriving in the subsequent cycle and persisting for 4 beats of the pipeline.
In one example, the pipeline 1000 includes a 64-bit instruction bus. The instruction bus delivers instruction bit patterns and relocated register addresses to the Load Store, Texture, and Interpolator. In one example, most uses of the instruction bus only need 12-odd bits to be transferred, but an instruction may need up to 60-bits to be transferred along with the 9 translated register file address bits.
In one example, the Rasterizer is handed a Primitive in the beginning of the pipeline 1000 flow. In one example, draw commands enter the pipeline 1000 from the graphics driver (or optionally from a command processor). Associated with a draw command is a graphics state (GS) (the current state of the OpenGL state machine for a pipeline implementing the OpenGL API). In one example, the Rasterizer determines if the primitive is in the current Tile, and if so, it sets up the Plane Equation Table for Setup, then proceeds to flow out Quads of pixels into the Interpolator coordinate buffer. The Interpolator uses the Plane Equation Tables for each Quad and interpolates the quads into frame coordinate space. The result may be delivered directly to the texture unit Texture Coordinate Buffer or it may be delivered to the Register File 420 of a processing element 400 (
In one example, the constructors 1005 are in charge of allocating and building WARPs for processing. In one example, this process consists of allocating a WARP, associating a Register File 420 with that WARP, filling the Register File 420 with initialization data and signaling the WARP manager 1030 to start this WARP into execution. The Load Store Unit performs memory reference instructions, and provides an interface between other fixed function units and the Register Files 420. In one example, the WARP manager 1030, Register File 420 and Computation Unit comprise the processing element 400 (
In one example, the EMIT unit routes data emitted from shader programs 1010 and 1020 down the graphics pipeline 1000 to the next stage of processing. Much of the time the emitted data is shipped to shared memory so that a new WARP in a potentially different processing element 400 (
In one example, a graphics processing slice consists of eight processing elements 400 (
In one example, the register file 420 of a WARP is controlled by the base offset contained within the WARP data structure. In one example, a register in an instruction is mapped into the Register File 420 by adding the base shifted up by 2 bits in the WARP to the register in the instruction. In one example, the add computation is performed by a 5-bit adder. In one example, a register address presented to centralized fixed function units contains a Processing Element Number, a Register File bit, and a register address. In one example, the low order 2 bits of the register address select the SRAM bank. The Processing element number routes the request to the Register File 420 of the appropriate processing element 400 while the Register File bit selects between a <thread> Register File access or a Scalar Register File access.
In one embodiment, the GPU (e.g., GPU 129,
In one embodiment, since texture is quad-based, four (4) threads are processed at a time. If a thread does not obtain follower threads quickly, it is eligible for replacement by another thread that hashes into the same location; but once a thread has follower threads it cannot be evicted from its hashed location. At the end of the per-thread procedure listed above, a hash-table results with up to eight (8) clusters, some containing just a single leader thread and others with one or more follower threads. In one example, priority encoding is used to select the top four (4) clusters with the maximum number of follower threads, so that the maximum power savings from clock-gating the most follower threads is obtained.
In one embodiment, the Texture clustering phase generates the following output from the hash-table:
In one example, the output from the texture phase typically includes return texture values for all threads. In one example, the active thread bit-vector, which consists of up to four (4) leader threads and other non-clustered threads are sent as output. For each of these threads, the color values from the texture unit are returned. In one example, the color values for the follower threads are not sent since they are the same as the color values for their leader threads. Each of the four cluster IDs is described by the cluster ID, the leader thread ID and a 32 b bit-vector of the follower threads.
In one example, assuming an 8-thread WARP, where ABAA_CDEE, denote that threads 0, 2 and 3 generated color A and threads 6 and 7 generated color E and threads 1, 4 and 5 are not clustered, the leader threads are 0 and 6. The active bit-vector of 1100—1110 includes the non-clustered threads 2, 4, and 5. The return color values are only A, B, C, D and E; the same color for threads 2 and 3 are not repeatedly sent back for instance. In this case, only two hashed locations have one or more follower threads, assuming these are 0 and 1, the example has:
In one embodiment, for cluster insertion in the processing element, a trace may consume multiple texture return values, each with their own clustering. In one example, the warp scheduler (WSQ) gets texture clustering from two (2) or more individual textures and re-clusters:
As an example to illustrate the need for cluster intersection, consider the following example where two distinct textures are consumed by a trace. One of the textures has been clustered by the texture unit to AABB, representing a simplified 4-thread WARP where threads 0 and 1 are in one thread cluster and threads 2 and 3 are in the other thread cluster. The other texture has been clustered to CDDD with thread 0 un-clustered and threads 1, 2 and 3 clustered. Since the trace consumes both textures, the best that can be done is to cluster together only those threads which consume the same values from both textures. In this example, threads 2 and 3 consume (B, D) and may be clustered. Threads 0 and 1 can no longer be clustered because even though both consume A from the first texture, they consume distinct C and D from the second texture. Hence, the WSQ has to perform a cluster intersection and generate an EFGG clustering where E=(A, C), F=(A, D) and G=(B, D). Following is one hardware scheme to implement this intersection.
In one embodiment, a thread is going to be clustered only if it is clustered in both textures. In this case, one has 1111 for the first texture indicating all threads are clustered and 0111 for the second texture indicating that thread 0 is not clustered. The AND is 0111. In one example, the concatenation step takes the cluster ID from the first texture and appends it to the cluster ID from the second texture, so the result is: (00_XX, 00—00, 01—00, 01—00). The table is updated for the clusterable threads which are 1, 2 and 3. The table contains [00—00→1, 01—00→2]. Since only 01—00 has a thread count>1, that is the only group that is clusterable after the intersection. The new leader thread is thread 3 from a leading one detect, and the follower bit-vector is 0001.
One or more embodiments may be implemented for vertex shaders. Vertex shaders have attribute and position inputs that are fetched from some memory locations. In order to implement one or more embodiments to vertex shaders, the HW implements cluster detection and an insertion scheme in the load-store unit (LSU). In this case, the incoming position and attribute values are treated the same way as the treatment of values returned by texture instructions in the PUSH-IPA model; and if the shader code is free from cross-thread dependencies, these thread clusters computed on a shader entry will persist for the whole execution of the shader.
One or more embodiments obtain power savings for a SIMD/T architecture by limiting execution to one thread in a thread cluster making clusterization decisions at the trace boundary. They also offer a simplified version of the same idea that allows the HW to find clusters once in the beginning of shader execution without having to re-clusterize threads later on. One or more embodiments implement procedures to detect and insert thread clusters based on return values from the texture unit or the load store unit.
In one embodiment, process 1100 may provide that the detecting includes analyzing dependencies of the many of different threads to determine if any identical sequences of instructions from different threads depend on values computed by other threads during compilation by a compiler. Process 1100 may further include analyzing potential reduction in power consumption in the processing environment based on the size of identical sequences of thread instructions without dependencies and redundancy computations based on a number of inputs for the many different threads.
Process 1100 may further provide that the detecting threads that include redundant work includes identifying identical sequences of instructions from the many different threads that have an identical set of input values. Identifying identical sequences of instructions may include reading from one of input registers for each of the many different threads or from output registers of a texture Interpolator, and implementing a data structure with following pair-wise compares of input registers of each of the plurality of different threads for avoiding false positive results.
In one embodiment, process 1100 may provide that the detecting further includes mapping the input registers of each of the many different threads that have identical values with the implemented data structure. The grouping may further include grouping the multiple threads with the identical sequences of instructions and the identical set of input values that will compute exactly same results into the one or more thread clusters. In one embodiment, process 1100 may provide that the grouping further includes identifying any cluster intersections across different identical sequences of instructions with a scheduler, and re-grouping intersected thread clusters by concatenating cluster ID and updating a bit-vector of threads in the one or more thread clusters.
In one embodiment, process 1100 may provide that the particular one thread in each of the one or more thread clusters is designated as a cluster leader thread, where each cluster leader thread has a minimum ID of the threads in a thread cluster, and the suppressing execution may include clock-gating off the execution of all non-cluster leader threads in the one or more thread clusters.
In one embodiment, process 1100 may provide that the broadcasting of the results includes broadcasting the results computed by each cluster leader thread to other threads in its thread cluster using an output register map from the compiler. In one embodiment, for process 100 the processing environment is included in a GPU of a mobile electronic device (e.g., electronic device 120,
The communication interface 517 allows software and data to be transferred between the computer system and external devices through the Internet 550, mobile electronic device 551, a server 552, a network 553, etc. The system 500 further includes a communications infrastructure 518 (e.g., a communications bus, cross-over bar, or network) to which the aforementioned devices/interfaces 511 through 517 are connected.
The information transferred via communications interface 517 may be in the form of signals such as electronic, electromagnetic, optical, or other signals capable of being received by communications interface 517, via a communication link that carries signals and may be implemented using wire or cable, fiber optics, a phone line, a cellular phone link, an radio frequency (RF) link, and/or other communication channels.
In one implementation of one or more embodiments in a mobile wireless device (e.g., a mobile phone, tablet, wearable device, etc.), the system 500 further includes an image capture device 520, such as a camera of camera interface 128 (
In one embodiment, the system 500 includes a thread processing interface 530 that may implement thread processing similar as described above referring to
As is known to those skilled in the art, the aforementioned example architectures described above, according to said architectures, can be implemented in many ways, such as program instructions for execution by a processor, as software modules or interfaces, microcode, as computer program product on computer readable media, as analog/logic circuits, as application specific integrated circuits, as firmware, as consumer electronic devices, AV devices, wireless/wired transmitters, wireless/wired receivers, networks, multi-media devices, etc. Further, embodiments of said Architecture can take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment containing both hardware and software elements.
One or more embodiments have been described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to one or more embodiments. Each block of such illustrations/diagrams, or combinations thereof, can be implemented by computer program instructions. The computer program instructions when provided to a processor produce a machine, such that the instructions, which execute via the processor create means for implementing the functions/operations specified in the flowchart and/or block diagram. Each block in the flowchart/block diagrams may represent a hardware and/or software module, interface or logic, implementing one or more embodiments. In alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures, concurrently, etc.
The terms “computer program medium,” “computer usable medium,” “computer readable medium”, and “computer program product,” are used to generally refer to media such as main memory, secondary memory, removable storage drive, a hard disk installed in hard disk drive. These computer program products are means for providing software to the computer system. The computer readable medium allows the computer system to read data, instructions, messages or message packets, and other computer readable information from the computer readable medium. The computer readable medium, for example, may include non-volatile memory, such as a floppy disk, ROM, flash memory, disk drive memory, a CD-ROM, and other permanent storage. It is useful, for example, for transporting information, such as data and computer instructions, between computer systems. Computer program instructions may be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
Computer program instructions representing the block diagram and/or flowcharts herein may be loaded onto a computer, programmable data processing apparatus, or processing devices to cause a series of operations performed thereon to produce a computer implemented process. Computer programs (i.e., computer control logic) are stored in main memory and/or secondary memory. Computer programs may also be received via a communications interface. Such computer programs, when executed, enable the computer system to perform the features of the embodiments as discussed herein. In particular, the computer programs, when executed, enable the processor and/or multi-core processor to perform the features of the computer system. Such computer programs represent controllers of the computer system. A computer program product comprises a tangible storage medium readable by a computer system and storing instructions for execution by the computer system for performing a method of one or more embodiments.
Though the embodiments have been described with reference to certain versions thereof; however, other versions are possible. Therefore, the spirit and scope of the appended claims should not be limited to the description of the preferred versions contained herein.
This application claims the priority benefit of U.S. Provisional Patent Application Ser. No. 62/018,000, filed Jun. 27, 2014, which is incorporated herein by reference in its entirety.
Number | Date | Country | |
---|---|---|---|
62018000 | Jun 2014 | US |