Patent Application
20220206796
The field of invention pertains generally to the computing sciences, and, more specifically, to a multi-functional execution lane for an image processor.
Image processing typically involves the processing of pixel values that are organized into an array. Here, a spatially organized two dimensional array captures the two dimensional nature of images (additional dimensions may include time (e.g., a sequence of two dimensional images) and data type (e.g., colors). In a typical scenario, the arrayed pixel values are provided by a camera that has generated a still image or a sequence of frames to capture images of motion. Traditional image processors typically fall on either side of two extremes.
A first extreme performs image processing tasks as software programs executing on a general purpose processor or general purpose-like processor (e.g., a general purpose processor with vector instruction enhancements). Although the first extreme typically provides a highly versatile application software development platform, its use of finer grained data structures combined with the associated overhead (e.g., instruction fetch and decode, handling of on-chip and off-chip data, speculative execution) ultimately results in larger amounts of energy being consumed per unit of data during execution of the program code.
A second, opposite extreme applies fixed function hardwired circuitry to much larger blocks of data. The use of larger (as opposed to finer grained) blocks of data applied directly to custom designed circuits greatly reduces power consumption per unit of data. However, the use of custom designed fixed function circuitry generally results in a limited set of tasks that the processor is able to perform. As such, the widely versatile programming environment (that is associated with the first extreme) is lacking in the second extreme.
A technology platform that provides for both highly versatile application software development opportunities combined with improved power efficiency per unit of data remains a desirable yet missing solution.
An apparatus is described that includes an execution unit having a multiply add computation unit, a first ALU logic unit and a second ALU logic unit. The ALU unit is to perform first, second, third and fourth instructions. The first instruction is a multiply add instruction. The second instruction is to perform parallel ALU operations with the first and second ALU logic units operating simultaneously to produce different respective output resultants of the second instruction. The third instruction is to perform sequential ALU operations with one of the ALU logic units operating from an output of the other of the ALU logic units to determine an output resultant of the third instruction. The fourth instruction is to perform an iterative divide operation in which the first ALU logic unit and the second ALU logic alternatively operate during an iteration to determine a quotient digit value.
An apparatus is described comprising an execution unit of an image processor. The ALU unit comprises means for executing a first instruction, the first instruction being a multiply add instruction. The ALU unit comprises means for executing a second instruction including performing parallel ALU operations with first and second ALU logic units operating simultaneously to produce different respective output resultants of the second instruction. The ALU unit comprises means for executing a third instruction including performing sequential ALU operations with one of the ALU logic units operating from an output of the other of the ALU logic units to determine an output resultant of the third instruction. The ALU unit comprises means for executing a fourth instruction including performing an iterative divide operation in which the first ALU logic unit and the second ALU logic unit operate to determine first and second digit resultant digit values.
The following description and accompanying drawings are used to illustrate embodiments of the invention. In the drawings:
The I/O unit 104 is responsible for loading input “sheets” of image data received into the data computation unit 101 and storing output sheets of data from the data computation unit externally from the stencil processor. In an embodiment, the loading of sheet data into the data computation unit 101 entails parsing a received sheet into rows/columns of image data and loading the rows/columns of image data into the two dimensional shift register structure 106 or respective random access memories 107 of the rows/columns of the execution lane array (described in more detail below).
If the sheet is initially loaded into memories 107, the individual execution lanes within the execution lane array 105 may then load sheet data into the two-dimensional shift register structure 106 from the random access memories 107 when appropriate (e.g., as a load instruction just prior to operation on the sheet's data). Upon completion of the loading of a sheet of data into the register structure 106 (whether directly from a sheet generator or from memories 107), the execution lanes of the execution lane array 105 operate on the data and eventually “write back” finished data externally from the stencil processor, or, into the random access memories 107. If the later the I/O unit 104 fetches the data from the random access memories 107 to form an output sheet which is then written externally from the stencil processor.
The scalar processor 102 includes a program controller 109 that reads the instructions of the stencil processor's program code from instruction memory 103 and issues the instructions to the execution lanes in the execution lane array 105. In an embodiment, a single same instruction is broadcast to all execution lanes within the array 105 to effect a SIMD-like behavior from the data computation unit 101. In an embodiment, the instruction format of the instructions read from scalar memory 103 and issued to the execution lanes of the execution lane array 105 includes a very-long-instruction-word (VLIW) type format that includes more than one opcode per instruction. In a further embodiment, the VLIW format includes both an ALU opcode that directs a mathematical function performed by each execution lane's ALU and a memory opcode (that directs a memory operation for a specific execution lane or set of execution lanes).
The term “execution lane” refers to a set of one or more execution units capable of executing an instruction (e.g., logic circuitry that can execute an instruction). An execution lane can, in various embodiments, include more processor-like functionality beyond just execution units, however. For example, besides one or more execution units, an execution lane may also include logic circuitry that decodes a received instruction, or, in the case of more MIMD-like designs, logic circuitry that fetches and decodes an instruction. With respect to MIMD-like approaches, although a centralized program control approach has largely been described herein, a more distributed approach may be implemented in various alternative embodiments (e.g., including program code and a program controller within each execution lane of the array 105).
The combination of an execution lane array 105, program controller 109 and two dimensional shift register structure 106 provides a widely adaptable/configurable hardware platform for a broad range of programmable functions. For example, application software developers are able to program kernels having a wide range of different functional capability as well as dimension (e.g., stencil size) given that the individual execution lanes are able to perform a wide variety of functions and are able to readily access input image data proximate to any output array location.
During operation, because of the execution lane array 105 and two-dimensional shift register 106, multiple stencils of an image can be operated on in parallel (as is understood in the art, a stencil is typically implemented as a contiguous N×M or N×M×C group of pixels within an image (where N can equal M)). Here, e.g., each execution lane executes operations to perform the processing for a particular stencil worth of data within the image data, while, the two dimensional shift array shifts its data to sequentially pass the data of each stencil to register space coupled to the execution lane that is executing the tasks for the stencil. Note that the two-dimensional shift register 106 may also be of larger dimension than the execution lane array 105 (e.g., if the execution lane array is of dimension X×X, the two dimensional shift register 106 may be of dimension Y×Y where Y>X). Here, in order to fully process stencils, when the left edge of the stencils are being processed by the execution lanes, the data in the shift register 106 will “push out” off the right edge of the execution lane array 105. The extra dimension of the shift register 106 is able to absorb the data that is pushed off the edge of the execution lane array.
Apart from acting as a data store for image data being operated on by the execution lane array 105, the random access memories 107 may also keep one or more look-up tables. In various embodiments one or more scalar look-up tables may also be instantiated within the scalar memory 103.
A scalar look-up involves passing the same data value from the same look-up table from the same index to each of the execution lanes within the execution lane array 105. In various embodiments, the VLIW instruction format described above is expanded to also include a scalar opcode that directs a look-up operation performed by the scalar processor into a scalar look-up table. The index that is specified for use with the opcode may be an immediate operand or fetched from some other data storage location. Regardless, in an embodiment, a look-up from a scalar look-up table within scalar memory essentially involves broadcasting the same data value to all execution lanes within the execution lane array 105 during the same clock cycle.
In an embodiment, the two dimensional shift register structure is implemented by permitting, during a single cycle, the contents of any of (only) one of registers R1 through R3 to be shifted “out” to one of its neighbor's register files through output multiplexer 203, and, having the contents of any of (only) one of registers R1 through R3 replaced with content that is shifted “in” from a corresponding one if its neighbors through input multiplexers 204 such that shifts between neighbors are in a same direction (e.g., all execution lanes shift left, all execution lanes shift right, etc.). In various embodiments, the execution lanes themselves execute their own respective shift instruction to effect a large scale SIMD two-dimensional shift of the shift register's contents. Although it may be common for a same register to have its contents shifted out and replaced with content that is shifted in on a same cycle, the multiplexer arrangement 203, 204 permits for different shift source and shift target registers within a same register file during a same cycle.
As depicted in
Although in one embodiment the content of only one register is permitted to be shifted per execution lane per cycle, other embodiments may permit the content of more than one register to be shifted in/out. For example, the content of two registers may be shifted out/in during a same cycle if a second instance of the multiplexer circuitry 203, 204 observed in
If less than all the content of an execution lane's register files are shifted out during a shift sequence note that the content of the non shifted out registers of each execution lane remain in place (do not shift). As such, any non shifted content that is not replaced with shifted in content persists local to the execution lane across the shifting cycle. A memory execution unit, not shown in
With respect to the ISA opcodes supported by the ALU unit 205 of the hardware execution lane 201, in various embodiments, the mathematical opcodes supported by the ALU unit 205 may include any of the following ALU operations: add (ADD), substract (SUB), move (MOV), multiple (MUL), multiply-add (MAD), absolute value (ABS), divide (DIV), shift-left (SHL), shift-right (SHR), return min or max (MIN/MAX), select (SEL), logical AND (AND), logical OR (OR), logical XOR (XOR), count leading zeroes (CLZ or LZC) and a logical complement (NOT). An embodiment of an ALU unit 205 or portion thereof described in more detail below with respect to
As observed in
The multiply add logic unit 403, in an embodiment, performs a full multiply-add instruction. That is, the multiply-add logic unit 403 performs the function (A*B)+(C,D) where A is a full width input operand, B is a full width operand and (C,D) is a concatenation of two full width operands to form a double width summation term. For example, if full width corresponds to 16 bits, A is 16 bits, B is 16 bits and the summation term is 32 bits. As is understood in the art, a multiply add of two full width values can produce a double width resultant. As such, the resultant of the MAD operation is written across the X, Y output ports where, e.g., X includes the top half of the resultant and Y includes the bottom half of the resultant. In a further embodiment the multiply-add unit 403 supports a half width multiply add. Here, e.g., the lower half of A is used as a first multiplicand, the lower half of B is used as a second multiplicand and either C or D (but not a concatenation) is used as the addend.
As mentioned above with respect to
Here, referring to
In an embodiment, the instruction format for executing the dual parallel full width ALU operation 302 includes an opcode that specifies dual parallel full width operation and the destination registers. In a further embodiment, the opcode, besides specifying dual parallel full width operation, also specifies one or two ALU operations. If the opcode only specifies one operation, both ALU logic units 401, 402 will perform the same operation. By contrast if the opcode specifies first and second different ALU operations, the first ALU logic unit 401 performs one of the operations and the second ALU logic unit 402 performs the second of the operations.
With respect to the half width (HW) feature of operation 302, four half width ALU operations are performed in parallel. Here, each of inputs A, B, C and D are understood to each include two separate input operands. That is, e.g., a top half of A corresponds to a first input operand, a lower half of A corresponds to a second input operand, a top half of B corresponds to a third input operand, a lower half of B corresponds to a fourth input operand, etc.
As such, ALU logic unit 401 handles two ALU operations in parallel and ALU logic unit 402 handles two ALU operations in parallel. Thus, during execution, all four half width operations are performed in parallel. At the end of the operation 302, ALU logic unit 401 writes two half width resultants into register X and ALU logic unit 402 writes two half width resultants into register Y. As such, there are four separate half width resultants in registers X and Y.
In an embodiment, the instruction format not only specifies that parallel half width operation is to be performed but also specifies which ALU operation(s) is/are to be performed. In various embodiments the instruction format may specify that all four operations are the same and only specify one operation and/or may specify that all four operations are different and specify four different operations. In the case of the later, alternatively, to effect same operations for all four operations the instructions format may specify the same operation four times. Various combinations of these instruction format approaches are also possible.
With respect to the double wide ALU operation 303 of
That is, in an embodiment, the C and D terms represent the lowered ordered halfs of the two double wide input operands. The second ALU logic unit 402 performs the specified operation (e.g., ADD) on the two lower halfs and the resultant that is generated corresponds to the lower half of the overall double wide resultant. As such, the resultant from the second ALU logic unit 402 is written into register Y. The operation on the lower halves may generate a carry term that is carried to the first ALU logic unit 401 which continues the operation of the two respective upper halves A and C of the input operands. The resultant from the first ALU logic unit 401 corresponds to the upper half of the overall resultant which is written into output register X. Because operation on the upper halves by the first ALU logic unit 401 may not be able to start until it receives the carry term from the second ALU logic unit 402, the operation of the ALU logic units 402, 401 is sequential rather than parallel. As such, as observed in
Nevertheless, because the MAD operation 301 can consume more time than two consecutive ALU logic unit operations, the machine can be built around an execution unit 405 that can attempt to insert as much function as it can into the time period consumed by its longest propagation delay operation. As such, in an embodiment, the cycle time of the execution unit 405 corresponds to the execution time of the MAD instruction 301. In an embodiment, the instruction format for a double wide operation specifies not only the operation to be performed, but also, that the operation is a double wide operation.
With respect to the FUSED operation 304, the execution unit 405 performs the operation (C op D) op B. Here, like the double wide ALU operation 303 discussed just above, the dual ALU logic units 401, 402 operate sequentially because the second operation operates on the resultant of the first operation. Here, the second ALU logic unit 402 performs the initial operation on full width inputs C and D. The resultant of the second ALU logic 402, instead of being written into resultant register space, is instead multiplexed into an input of the first ALU logic unit 401 via multiplexer 406. The first ALU logic unit 401 then performs the second operation and writes the resultant into register X.
In a further embodiment, a half width FUSED operation can also be performed. Here, operation is as described above except that only half of the input operands are utilized. That is, for example, in calculating (C op D) op B, only the lower half of C and the lower half of D are used to determine a half width result for the first operation, then, only the lower half of B is used along with the half width resultant of the first operation to perform the second operation. The resultant is written as a half width value in register X. Further still, two half width FUSED operations can be performed in parallel. Here, operation is as described just above simultaneously with the same logical operations but for the high half of the operands. The result is two half with values written into register X.
In an embodiment, the instruction format for a FUSED operation specifies that a FUSED operation is to be performed and specifies the two operations. If the same operation is be performed twice, in an embodiment, the instruction only specifies the operation once or specifies it twice. In a further embodiment, apart from specifying FUSED operation and the operation(s) to be performed, the instruction format may further specify whether full width or half width operation is to be performed.
Operation 306 of
For simplicity, 16 bit division will be described (those of ordinary skill will be able to extend the present teachings to different width embodiments). With the embodiment described herein performing two long division atomic acts, eight sequential executions of the instruction are used to fully divide a 16 bit numerator by a 16 bit divisor. That is, each atomic long division act corresponds to the processing of a next significant bit of the numerator. Two such significant bits are processed during a single execution of the instruction. Therefore, in order to process all bits of the numerator, eight sequential executions of the instruction are needed to fully perform the complete division. The output of a first instruction is written to the register file and used as the input for the next subsequent instruction.
Referring to
Referring to
Different data processing procedures are then followed depending on the sign 512 of the result of the subtraction 511. Importantly, the first quotient resultant bit (i.e., the first bit of the division result) is staged to be written into the second to least significant bit of the Y output port 509 (“NEXT B[1]”). If the result of the subtraction is negative, the quotient resultant bit B[1] is set 513 to a 0. If the result of the subtraction is positive, the quotient resultant bit B[1] is set 514 to a 1. The setting of this bit corresponds to the process in long division where the first digit of the quotient result is determined by establishing whether or not the divisor value can be divided into the first digit of the numerator.
Additionally, two different data structures are crafted and presented to respective input ports (“1”, “2”) of a multiplexer 506 (which may be the same multiplexer as multiplexer 406 of
The second crafted data structure corresponds to a left shift of the result of the subtraction 511 that was just performed by the second ALU logic unit 502 appended with bit B[13] and is presented at the second input (“2”) of the multiplexer 506. The creation of this data structure corresponds to the situation in long division where a divisor divides into the first digit(s) of the numerator which sets up a next division into the result of the difference between first digit(s) of the numerator and a multiple of the divisor.
The first or second data structures are then selected by the multiplexer 506 depending on whether the result of the subtraction performed by the second ALU logic unit 502 yielded a positive or negative result. If the subtraction yielded a negative result (which corresponds to the divisor not being able to be divided into the next significant digit of the numerator), the first data structure is selected 513. If the subtraction yielded a positive result (which corresponds to the divisor being able to be divided into the next significant digit of the numerator), the second data structure is selected 514.
The output of the multiplexer 506 is now understood to be the new most significant word of the PACK data structure (new PACK msw) and corresponds to the next value in a long division sequence that the divisor is to be attempted to be divided into. As such, the first ALU logic unit 501 subtracts 515 the divisor D from the new PACK msw value. The least significant bit 510 of the Y output B[0] is staged to be written as a 1 or a 0 depending on the sign of the subtraction result from the first ALU 501 and represents the next digit in the quotient resultant 517, 518.
A second multiplexer 508 selects between first and second data structures depending 516 on the sign of the first ALU logic unit's subtraction 515. A first data structure, presented at input “1” of the second multiplexer 508, corresponds to the new PACK msw value. A second data structure, presented at input “2” of the second multiplexer 508, corresponds to the result of the subtraction performed by the first ALU logic unit 501. Which of the two data structures is selected depends on the sign of the result of the subtraction 515 performed by the first ALU 501. If the result of the subtraction is negative, the multiplexer selects the new PACK msw value 517. If the result of the subtraction is positive, the multiplexer selects the new PACK msw—D value 518.
The output of the second multiplexer 508 corresponds to the NEXT A value which is written into the register file from the X output. The value presented at the Y output (B[15:0]) is composed at the leading edge of the B operand less its two most significant bits that were consumed by the two just performed iterations (B[13:0]). The concatenation of these remainder bits of B with the two newly calculated quotient digit resultants are written into the register file as the new B operand NEXT B. For a next iteration, the X output from the previous instruction is read into the A operand and the Y output from the previous instruction is read into the B operand. The process then repeats until all digits of the original B operand have been processed (which, again, in the case of a 16 bit B operand will consume eight sequential executions of the instruction). At the conclusion of all iterations, the final quotient will be written into the register file from the Y output and any remainder will be represented in the NEXT A value which is written into the register file from the X output.
It is pertinent to point out that the various image processor architecture features described above are not necessarily limited to image processing in the traditional sense and therefore may be applied to other applications that may (or may not) cause the image processor to be re-characterized. For example, if any of the various image processor architecture features described above were to be used in the creation and/or generation and/or rendering of animation as opposed to the processing of actual camera images, the image processor may be characterized as a graphics processing unit. Additionally, the image processor architectural features described above may be applied to other technical applications such as video processing, vision processing, image recognition and/or machine learning. Applied in this manner, the image processor may be integrated with (e.g., as a co-processor to) a more general purpose processor (e.g., that is or is part of a CPU of computing system), or, may be a stand alone processor within a computing system.
The hardware design embodiments discussed above may be embodied within a semiconductor chip and/or as a description of a circuit design for eventual targeting toward a semiconductor manufacturing process. In the case of the later, such circuit descriptions may take of the form of a (e.g., VHDL or Verilog) register transfer level (RTL) circuit description, a gate level circuit description, a transistor level circuit description or mask description or various combinations thereof. Circuit descriptions are typically embodied on a computer readable storage medium (such as a CD-ROM or other type of storage technology).
From the preceding sections is pertinent to recognize that an image processor as described above may be embodied in hardware on a computer system (e.g., as part of a handheld device's System on Chip (SOC) that processes data from the handheld device's camera). In cases where the image processor is embodied as a hardware circuit, note that the image data that is processed by the image processor may be received directly from a camera. Here, the image processor may be part of a discrete camera, or, part of a computing system having an integrated camera. In the case of the later the image data may be received directly from the camera or from the computing system's system memory (e.g., the camera sends its image data to system memory rather than the image processor). Note also that many of the features described in the preceding sections may be applicable to a graphics processor unit (which renders animation).
As observed in
An applications processor or multi-core processor 750 may include one or more general purpose processing cores 715 within its CPU 701, one or more graphical processing units 716, a memory management function 717 (e.g., a memory controller), an I/O control function 718 and an image processing unit 719. The general purpose processing cores 715 typically execute the operating system and application software of the computing system. The graphics processing units 716 typically execute graphics intensive functions to, e.g., generate graphics information that is presented on the display 703. The memory control function 717 interfaces with the system memory 702 to write/read data to/from system memory 702. The power management control unit 712 generally controls the power consumption of the system 700.
The image processing unit 719 may be implemented according to any of the image processing unit embodiments described at length above in the preceding sections. Alternatively or in combination, the IPU 719 may be coupled to either or both of the GPU 716 and CPU 701 as a co-processor thereof. Additionally, in various embodiments, the GPU 716 may be implemented with any of the image processor features described at length above.
Each of the touchscreen display 703, the communication interfaces 704-707, the GPS interface 708, the sensors 709, the camera 710, and the speaker/microphone codec 713, 714 all can be viewed as various forms of I/O (input and/or output) relative to the overall computing system including, where appropriate, an integrated peripheral device as well (e.g., the one or more cameras 710). Depending on implementation, various ones of these I/O components may be integrated on the applications processor/multi-core processor 750 or may be located off the die or outside the package of the applications processor/multi-core processor 750.
In an embodiment one or more cameras 710 includes a depth camera capable of measuring depth between the camera and an object in its field of view. Application software, operating system software, device driver software and/or firmware executing on a general purpose CPU core (or other functional block having an instruction execution pipeline to execute program code) of an applications processor or other processor may perform any of the functions described above.
Embodiments of the invention may include various processes as set forth above. The processes may be embodied in machine-executable instructions. The instructions can be used to cause a general-purpose or special-purpose processor to perform certain processes. Alternatively, these processes may be performed by specific hardware components that contain hardwired logic for performing the processes, or by any combination of programmed computer components and custom hardware components.
Elements of the present invention may also be provided as a machine-readable medium for storing the machine-executable instructions. The machine-readable medium may include, but is not limited to, floppy diskettes, optical disks, CD-ROMs, and magneto-optical disks, FLASH memory, ROMs, RAMs, EPROMs, EEPROMs, magnetic or optical cards, propagation media or other type of media/machine-readable medium suitable for storing electronic instructions. For example, the present invention may be downloaded as a computer program which may be transferred from a remote computer (e.g., a server) to a requesting computer (e.g., a client) by way of data signals embodied in a carrier wave or other propagation medium via a communication link (e.g., a modem or network connection).
In the foregoing specification, the invention has been described with reference to specific exemplary embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.
This application is a continuation of and claims priority to U.S. patent application Ser. No. 16/251,887, filed on Jan. 18, 2019, which is a continuation of and claims priority to U.S. patent application Ser. No. 15/591,955, filed on May 10, 2017 (now U.S. Pat. No. 10,185,560), which is a continuation of U.S. patent application Ser. No. 14/960,334, filed on Dec. 4, 2015 (now U.S. Pat. No. 9,830,150). The disclosures of the prior applications are considered part of and are incorporated by reference in the disclosure of this application.
| Number | Date | Country | |
|---|---|---|---|
| Parent | 16251887 | Jan 2019 | US |
| Child | 17691615 | US | |
| Parent | 15591955 | May 2017 | US |
| Child | 16251887 | US | |
| Parent | 14960334 | Dec 2015 | US |
| Child | 15591955 | US |
