Patent Application
20220413852
The disclosure described herein generally relates to vector processor architectures and, in particular, to techniques for exploiting the properties of streaming data using a local buffer embedded in the execution units of the vector processor architecture to reduce the use of a centralized memory, shared interconnection networks, and power consumption.
A vector processor or array processor is a central processing unit (CPU) that implements an instruction set containing instructions that operate on one-dimensional arrays of data referred to as “vectors.” This is in contrast to scalar processors having instructions that operate on single data items. Vector processors can greatly improve performance on certain workloads, notably numerical simulation and similar tasks, by utilizing a number of execution units that independently execute specific functions on incoming data streams to achieve a processing flow. However, current implementation of vector processors to achieve a processing flow presents various drawbacks.
The accompanying drawings, which are incorporated herein and form a part of the specification, illustrate the various implementations of the present disclosure and, together with the description, and further serve to explain the principles of the implementations and to enable a person skilled in the pertinent art to make and use the techniques in accordance with the implementations as discussed herein.
The various techniques in accordance with the present disclosure will be described with reference to the accompanying drawings. The drawing in which an element first appears is typically indicated by the leftmost digit(s) in the corresponding reference number.
In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present disclosure. However, it will be apparent to those skilled in the art that the various techniques and implementations, including structures, systems, and methods, may be practiced without these specific details. The description and representation herein are the common means used by those experienced or skilled in the art to most effectively convey the substance of their work to others skilled in the art. In other instances, well-known methods, procedures, components, and circuitry have not been described in detail to avoid unnecessarily obscuring the disclosure.
Generally speaking, conventional CPUs manipulate one or two pieces of data at a time. For instance, conventional CPUs may receive an instruction that essentially says “add A to B and put the result in C,” with ‘C’ being an address in memory. Typically the data is rarely sent in raw form, and is instead “pointed to” via passing an address to a memory location that holds the actual data. Decoding this address and retrieving the data from that particular memory location takes some time, during which a conventional CPU sits idle waiting for the requested data to be retrieved. As CPU speeds have increased, this memory latency has historically become a large impediment to performance.
Thus, to reduce the amount of time consumed by these steps, most modern CPUs use a technique known as instruction pipelining in which the instructions sequentially pass through several sub-units. The first sub-unit reads and decodes the address, the next sub-unit “fetches” the values at those addresses, while the next sub-unit performs the actual mathematical operations. Vector processors, which are otherwise known as array processors, take this concept even further. For instance, instead of pipelining just the instructions, vector processors also pipeline the data itself. For example, a vector processor may be fed instructions that indicate not to merely add A to B, but to add all numbers within a specified range of address locations in memory to all of the numbers at another set of address locations in memory. Thus, instead of constantly decoding the instructions and fetching the data needed to complete each one, a vector processor may read a single instruction from memory. This initial instruction is defined in a manner such that the instruction itself indicates that the instruction will repeatedly be executed on another item of data, at an address one increment larger than the last. This allows for significant savings in decoding time.
Vector processors may be implemented in accordance with various architectures, and the various vector processor architectures as discussed throughout the disclosure as further described herein may be implemented in accordance with any of these architectures or combinations of these architectures.
Thus, the load-store instruction architecture facilitates data stored in the vector data memory 201 that is to be processed to be loaded into the vector registers 202.1-202.N using load operations, transferred to the execution units 204.1-204.N, processed, written back to the vector registers 202.1-202.N, and then written back to the vector data memory 201 using store operations. The location (address) of the data and the type of processing operation to be performed by each execution unit 204.1-204.N is part of an instruction stored as part of the instruction set in the program memory 206. The movement of data between these various components may be scheduled in accordance with a decoder that accesses the instructions sets from the program memory, which is not shown in further detail in
The use of instruction sets in accordance with the vector processor architecture 200 is generally known, and therefore an additional description of this operation is not provided for purposes of brevity. Regardless of the particular implementation, vector processors can greatly improve performance on certain workloads but have various drawbacks. For instance, it is very common in many signal processing applications for a specific vector data sample to be used many times in the calculation of an expression. In one scenario, and as further discussed herein, for the implementation of a finite impulse response (FIR) filter each vector data sample is multiplied by every coefficient of the filter. Thus, if a filter has 127 coefficients, then each vector data sample will be used as the input to 127 multiply-accumulate operations. This property is referred to as “data reuse.” In conventional vector processors, such as the vector processor architecture 200 as shown in
One drawback of this scheme is that, to enable practical compiler design, the vector registers 202.1-202.N must be implemented with aligned access. This is illustrated in
Furthermore, it is common for several execution units 204.1-204.N to concurrently transfer data across the interconnection network to the vector register files 202.1-202.N, which may result in data bottlenecks. The disclosure as further described herein addresses these issues by implementing a local or “private” buffer as part of each execution unit that enables the storage of vector data samples in the buffers in an unaligned manner, which is further discussed in further detail below with reference to
As noted above with reference to the vector processor architecture 200 as shown in
The vector processor architecture 300 may also include any suitable number of execution units 304.1-304.N, which may implement any suitable type of vector processors, vector processing circuitry, etc., illustrated in
Each of the execution units 304.1-304.N is configured to perform a specific type of mathematical operation via bit manipulation such as multiplication, addition, etc. Each of the execution units 304.1-304.N includes respective processor circuitry 310.1-310.N and is configured to execute, for each clock cycle, a specific type of instruction based upon the particular mathematical operation that is to be performed. Thus, the execution units 304.1-304.N are configured to independently execute one vector processor instruction each clock cycle in parallel with one another. Because these instruction may be different than one another, the use of multiple execution units 304.1-304.N means that the vector processor architecture 300 may execute N number of instructions in parallel each clock cycle.
The vector processor architecture 300 may form part of or the entirety of a system on a chip (SoC), which may be part of a larger overall system in which the vector processor architecture 300 is implemented. That is, the vector processor architecture 300 may be instantiated as part of a broader SoC that may include several other processors, ports, I/O, etc. In such a scenario, the I/O data coupled to the vector data memory 301 as shown in
Therefore, in contrast to the vector processor architecture 200 as shown in
It is noted that for streaming applications the data is processed in a sequential order. Thus, a natural memory structure for streaming data is a circular buffer. The buffers 308.1-308.N may thus be implemented as circular buffers and be configured such that data is written into or towards the end (or other address location) of the circular buffer and read from or towards the beginning (or other address location) of the circular buffer in terms of the buffer's addressable space. Another advantage of using such a circular buffer configuration includes the ability to utilize simplified modulo addressing to read data from and write data to the circular buffer. As it is not practical for compilers to support circular addressing for the vector registers 302.1-302.N, the use of the local buffers 308.1-308.N, which may locally implement such circular addressing, is particularly advantageous and overcomes this issue. Moreover, in many streaming applications such as FIR filters, mixers, and DPD actuators used in Digital Front-Ends (DFEs), the processing may be formulated as a single instruction that is repeatedly executed in a single execution unit 304.1-304.N. Again, transferring data to and from the vector registers 302.1-302.N over the shared interconnection network is expensive in terms of both cost and power due to the complex architecture of interconnection networks and their typical implementation to support “many-to-many” communication features in accordance with vector processor architecture and design.
It is also noted that the use of the buffers 308.1-308.N differs from the use of a cache memory in various ways. A cache memory facilitates random access of the data stored therein. This feature requires cache memory to implement complex hardware that allows a check to be performed regarding whether the cache currently contains data that needs to be retrieved. Such features also result in processor stalls while waiting for the cached data to be retrieved. The complex hardware used for cache operation enables prefetch and predictive operations to be executed, which adds to their cost thereby limiting their practical implementation. The vector processor architecture 300 described herein may leverage the use of the buffers 308.1-308.N by exploiting the sequential nature of vector processing operations for certain applications, such as filter processor computations, that utilize streaming data. As discussed herein, the use of the buffers 308.1-308.N as part of the vector processor architecture 300 exploits the sequential and predictive nature of the computations performed for certain applications to eliminate the need for costly and complex data caches. The vector processor architecture 300 as described herein may be implemented in accordance with any suitable type of application that utilizes vector processing operations in accordance with any suitable type of vector processor instructions. The vector processor instructions may be generated by any suitable controller, processor component, etc., such as the decoder 320 as shown in
The buffers 308.1-308.N may each be further partitioned into any suitable number of additional buffers or “sub-buffers,” which may be referred to herein as virtual buffers or buffer partitions. Each buffer or virtual buffer, as the case may be, which is identified with each respective buffer 308.1-308.N, may have any suitable type of address organization and be identified with a range of addresses representing the overall capacity of that particular buffer or virtual buffer. For ease of explanation, the buffer or virtual buffers discussed herein are referred to as having a range of addresses identified with “rows” and “columns,” although this is not a limitation of the implementation of the vector processor architecture 300 and any suitable type of addressing scheme or organization may be implemented by the buffers 308.1-308.N. Alternatively, the rows as discussed herein may be alternatively referred to as words, with one word or more words occupying each row. Regardless of the particular address organization that is utilized, the buffers or virtual buffers may store sets of vector data samples over any suitable range of address locations, which need not be “aligned” with the beginning of a row, as shown in
This is enabled via the use of the aforementioned read pointers that are contained or otherwise encoded as part of each received vector processor instruction. The vector processor instructions may also include or otherwise encode write pointers, which specify the location within buffer to store the results of the vector processing operations performed on the vector data samples, the results being illustrated in
Moreover, each buffer or virtual buffer may be identified with a distinct vector data stream, with the vector processing operations being sequentially applied to vector data samples for each distinct data stream to calculate results in accordance with the type of vector processing operation that is performed. The vector processing operations may be sequentially executed over several respective clock cycles, with new vector data samples being retrieved from the vector registers 302.1-302.N and, once no longer needed for further vector processing operations, the previous vector data samples stored in the buffer or virtual buffer may be overwritten with the new (i.e. more recently retrieved) vector data samples. In this way, the buffer or virtual buffers as described herein function in a circular manner by advancing, within each buffer, the next range of addresses used to store new vector data samples, and then returning to the original starting address over time as subsequent vector processing operations are performed and completed on older vector data samples. Further details of the streaming nature of the buffers and virtual buffers are discussed below with respect to the illustrative implementations.
The address range that is incremented or offset between subsequent vector processing operations for both the read pointer and the write pointer may advantageously be (but not necessarily be) a fixed or static offset value, which may be identified at compile time when the vector processor instructions are initially generated. The use of a static increment or offset may be particularly useful, as the calculation of the next starting address identified by each subsequent read pointer and write pointer may be determined in a straightforward manner with a priori knowledge of the address range of each buffer and the data rate and without performing additional complex processing tasks. The operation of the vector processing architecture 300 in accordance with a fixed I/O data rate may be leveraged to use of a static address increment between subsequent vector processing operations. In other words, because the buffers 308.1-308.N may retrieve vector data samples from the vector registers 302.1-302.N in accordance with a fixed or static data rate, this may be exploited to simplify the computation of the read and write pointer address offset calculations between subsequent vector processing operations, as the number of vector data samples to be processed each clock cycle may be fixed and thus a predetermined value that is related to the fixed data rate in terms of clock cycles.
The use of the buffers 308.1-308.N enables data access starting at any word and with no overhead. That is, once the vector processing operations have been completed, the results may be read from the buffers 308.1-308.N in an unaligned manner and loaded into the vector registers 302.1-302.N using store operations. This is illustrated in
To adapt to the unaligned manner in which the vector data samples are stored in the buffer 450, the vector processor architecture 300 may include one or more data rotators such as the data rotator logic 456 as shown in
Again, this alignment is achieved using the data rotator logic 456 as shown in
Thus, in contrast to the unaligned access from the 4-entry 8 word register file as shown in the unaligned access scenario 462 in
With respect to the vector processing operations, these operations may be any suitable type of function that operates on the vector data samples stored in each execution unit 304's respective local buffer 308.1-308.N, which is retrieved by each respective execution unit 304 from one or more of the vector registers 302.1-302.N in accordance with the received vector processor instruction. Such functions may be implemented as part of the particular application in which the vector processing architecture 300 is utilized, which may be digital signal processing operations for wireless communications, such as filter tap contribution calculations, digital pre-distortion (DPD) coefficient or term calculations, average signal measurement calculations over time, digital signal processing of signals transmitted or received via individual antenna data streams for multiple-input-multiple-output (MIMO) antenna systems, etc. Furthermore, the vector data samples as discussed herein may be part of an in-phase (I) quadrature-phase (Q) data stream, which may be processed prior to data transmission of wireless signals or after receiving the wireless signals. Additionally or alternatively, such functions may be implemented as part of graphics processing unit (GPU) to perform graphics processing and/or rendering. Two implementations for the vector processing operations performed by the execution units 304.1-304.N of the vector processor architecture 300 are provided in further detail in each Section below, although these are non-limiting scenarios as the vector processing architecture 300 may be implemented to in accordance with any suitable type of application and implementation, as noted above.
Again, the buffers 308.1-308.N, which may be further partitioned into any suitable number of virtual buffers as described herein, may function in a streaming manner. This means that as each vector processing operation is performed on a set of vector data samples, which may have a size equal to one or more data vectors, the read pointer is incremented or advanced by some address range to create an address offset between vector processing operations. This address range increment or offset may be less than the address range spanned by the entire set of vector data samples (an address range for 64 vector data samples as shown in the illustrated scenario of
That is, and with reference now to
In both cases, the starting position of the set of vector data samples read for each vector processing operation is incremented from the previous vector processing operation in accordance with the starting address location within the buffer as indicated by the read pointer. However, the set of data samples accessed between consecutive vector processing operations partially overlap with one another. In other words, consecutive data processing operations re-use a portion of the set of 64 vector data samples. The particular portion of “overlapping” or re-used vector data samples may vary depending upon the particular application and vector processing operations performed. In any event, the various vector processing operations may be performed in this manner until the entire vector data samples stored in the buffer are processed, thereby resulting in the calculation of one or more DPD coefficients in this particular scenario.
In other words, several vector processing operations may be performed over a series of clock cycles, as noted above. Prior to the vector processing operations being performed, the buffer may store any suitable number of vector data samples, such as 512 vector data samples using the illustration as shown in
Then, for a subsequent clock cycle, the vector processing circuitry 310.1-310.N performs a vector processing operation in response to receiving another vector processor instruction using a second portion of the stored set of vector data samples that are read from the buffer (from an incremented or offset starting address as indicated by the read pointer included in the next vector processor instruction), and which may correspond to the next vector processing operation as shown in the second step in each of the top and bottom scenarios as shown in
As another application scenario, an asymmetric filter, which is a finite impulse response (FIR) filter for illustrative purposes in this implementation, are typically implemented in transceivers as part of digital signal processing operations. FIR filters implement a series of taps assigned to a number of filter coefficients, which are applied to incoming data streams to perform digital filtering. FIR filters are implemented having any suitable number of taps depending upon the particular application or implementation, and which may be related to the operating frequency of the wireless communications and the desired frequency response. The calculations as discussed further herein with respect to
The FIR filter output for a particular data stream represents the application of a set of coefficients to each of the filter taps. As discussed in further detail below, this is accomplished by reading, for each vector processing operation, a number of vector data samples from one of the buffers 308.1-308.N over a range of addresses, with the start of the address range as indicated by the read pointer noted above. Each vector processing operation in this scenario functions to multiply the FIR filter coefficients by each one of the vector data samples read from the buffer address range, which are then added together to compute the final contribution of each of the FIR filter taps in accordance with the FIR filter coefficients. As further discussed below with reference to
Turning now to
The data samples represented by one or more data vectors stored in the input buffer 602.1 and the output buffer 602.2 may be referred to herein as a set of vector data samples. The sets of vector data samples stored in the buffer 602.1 as referred to herein may thus be identified with any number of vector data samples of two or more. Thus, a set of vector data samples may be associated with any suitable number of data vectors or, alternatively, a set of vector data samples may be associated with a number of vector data samples contained in less than a single data vector. For ease of explanation and not by way of limitation, the term “set of vector data samples” as used for the FIR filter calculations with reference to
As shown in
Although any suitable number of data vectors may be retrieved and loaded into the input buffer 602.1, this requires additional complexity and bandwidth with respect to the interconnection network, and therefore a suitable compromise such as 2 data vectors may be a typical implementation. Also, it is noted that for this 8-tap asymmetric filter implementation, the number of vector data samples required to compute a single data vector (containing 8 vector data samples in this case) is equal to the number of vector data samples in the data vector (8 in this case), plus the total number of coefficients (8 in this scenario for an 8 tap FIR implementation), minus 1. Thus, 15 total vector data samples are needed to compute a single data vector including 8 vector data samples, and therefore retrieving and writing two data vectors in one vector processing operation is sufficient for this particular implementation.
During a subsequent vector processing operation as shown in
During a subsequent vector processing operation as shown in
With reference to
As noted above for the DPD implementation, several vector processing operations may be performed over several clock cycles without the need for the execution units 304.1-304.N to retrieve additional vector data samples from the vector registers 302.1-302.N. This is also true in this implementation, as illustrated in
During a subsequent vector processing operation as shown in
During the subsequent vector processing operation as shown in
The vector processor instruction indicates the location of the starting address using the read pointer, and the relevant execution unit 304.1-304.N may utilize the vector processor instructions together with knowledge regarding the range of addresses identified with the buffer 602.1 to retrieve the vector data samples in this manner, i.e. by “wrapping” around the range of vector address from X15 at row 7 to continue to retrieve the remainder of the vector data samples X16-X18 at column 6. This wrapping feature is a function of the buffers 602.1, 602.2 being implemented as circular in nature, and the particular manner in which vector data samples may be distributed across the input buffer 602.1 and the output buffer 602.2 may be in any suitable manner. The address range of each respective buffer thus defines a circular pattern of storage of vector data samples, which are eventually overwritten as new vector data samples are retrieved, as further discussed below. This advantageously enables the size of the input buffer 602.1 and output buffer 602.2 to be particularly small.
The read pointer as indicated by the vector processor instruction points to a vector address location in the input buffer 602.1 that is incremented or offset from the address location of the previous read pointer for the previous vector processing operation (
During a subsequent vector processing operation as shown in
Thus, after two additional vector processing operations are performed as shown in
In other words, the vector processor instruction used to instruct the relevant execution unit 304.1-304.N to perform the vector processing operation in each of
This process of performing vector processing operations on the data read from the input buffer 602.1 and storing the results of the calculations in the output buffer 602.2 may be repeated for any suitable number of vector processing operations, with the read pointer being incremented as indicated by each subsequent vector processor instruction. Turning now to
Another advantageous use of the input buffer 602.1 and the output buffer 602.2 is overwriting older vector data samples from previous vector processing operations that are no longer needed. This may be triggered by the read pointer address location being advanced to a starting address location in the input buffer 602.1 beyond a predetermined address range. That is, and as shown in
Thus, during two subsequent vector processing operations as shown in
The output buffer 602.2 may likewise contain vector data samples that are periodically overwritten as they become irrelevant or unneeded. The results stored as vector data samples after a number of vector processing operations have been performed as shown in
Thus, and as shown in
Thus, and as shown in
As shown in
Thus, the vector processing operations may be cascaded or chained sequentially, with subsequent vector processing stages (such as FIR0, FIR1, FIR2, etc.) being applied to the results of the previous vector processing calculations. The data may (but need not necessarily) flow through the functional pipeline of several cascaded vector processing operations in this manner at a fixed rate. Again, the use of a fixed data rate may advantageously allow for the vector processor instructions to be calculated in a less complex manner and/or in a less processor-intensive manner. As an additional advantage of such cascading vector processing architectures, all control may be computable at compile time to render appropriate vector data processor instructions based upon the particular application, the number of stages, the type of vector processing operations performed by each stage, etc.
With respect to the vector processor instructions, these may include any suitable type of machine-readable code, opcode, etc. that may be read by the execution units 304.1-304.N and/or the processor circuitry 310.1-310.N implemented by each of the execution units 304.1-304.N, as discussed herein. The vector processor instructions may identify a number of computations to perform, a number and location (such as a read pointer address location) from which to retrieve vector data samples from the vector data registers 302.1-302.N, a number of vector data samples to retrieve from the vector registers 302.1-302.N, a location from which the vector data samples are stored or written to the buffers 308.1-308.N (such as write pointer address starting locations), a location (such as a read pointer starting address location), the number and/or type of vector processing operations to perform on vector data samples read form the buffers 308.1-308.N, a location (such as a write pointer starting address location) in the buffers 308.1-308.N to write the results of performing the vector processing operations, etc.
In one illustrative scenario, the vector processor instruction may include an instruction to compute an FIR on a stream of vector data samples, such as the vector processing operations as discussed herein with respect to
Thus, a vector processor instruction may contain any suitable number of operands representing a number of bits that encode a specific instruction in accordance with the particular vector processing operation and implementation. The general syntax for such a vector processor instruction may be represented as follows:
operation (<FU>, A, B, D, E, F, R, S, T);
The vector processor instruction thus functions to instruct a corresponding execution unit 304.1-304.N that receives the vector processor instruction to perform a specific task. Thus, the vector processor instruction may be executed by the processing circuitry 310.1-310.N of a corresponding execution unit 304.1-304.N in accordance with any suitable type of software language, machine code, opcode, etc., which may be a set of predetermined software instructions, a hardware implementation, or combinations of both. The various vector processor instructions may have any suitable format depending upon the particular compiler and language used by the vector processor architecture 300. The instructions illustrated in Table 1 below may form part of the instruction sets stored in the program memory 306, which may be generated by the decoder 320 in accordance with a predetermined type of machine-readable code that is executed by the execution units 304.1-304.N in accordance with a predetermined machine-readable and executable software instruction set. The specific arrangement of bits represented by each operand of the vector processor instruction may cause the execution units 304.1-304.N to execute specific vector processing operations. The first operand of the vector processor instruction may include a control field such as ctrl:, which is indexed to the particular data vector being processed (much as 0, 1, 2, etc.) As one scenario, a vector processor instruction for performing FIR a filtering operation may be expressed as follows:
vec_filter(ctrl0, ctrl1, vec_in0, vec_in1, vec_acc_in, vec_out1, vec_out1, vec_acc_out).
The vector processor architecture as discussed herein may implement any suitable number of vector processor instructions, with a sample or subset of some vector processor instructions being represented in Table 1 below and additional operands and fields shown in Tables 2-4 below. Of course, the vector processor architecture may include alternate, additional, and fewer instructions, fields, operands, etc. depending upon the particular operation being performed and the particular application.
Again, a vector processor instruction may contain any suitable number of operands, each encoding a specific instruction in accordance with the particular vector processing operation and implementation. Thus, the syntax for an FIR filter vector processor instruction may be represented as follows:
v_fir_filter (<FU>, A, B, D, E, F, R, S, T);
with <FU> being a specific field with respect to the particular compiler used to generate the instruction. Table 2 below summarizes a set of such operands, which are explained in further detail below.
Such a vector processing instruction may represent a vector FIR filter operation processor instruction and be utilized by one of the execution units 304.1-304.N to implement various kinds of FIR filters, including non-symmetric, anti-symmetric, symmetric filter, half band interpolation and decimation filter, etc. For symmetric filters, including anti-symmetric filters, symmetry may be exploited to reduce the multiplication number. Thus, for this operation, it is assumed that filter coefficients are pre-arranged and stored in an on-chip lookup table (LUT). The on-chip LUT size may be any suitable size depending upon the particular application, such as 1024×32 bits. The LUT may thus hold up to 2048 16-bit real coefficients in such a case.
The Tables 3 and 4 further include various fields and their accompanying description, which may be implemented to perform filter computations as noted herein or any other suitable type of vector processing operations. Thus, continuing the above scenario, the input vectors D, E may each contain 32 bit vector data samples for a total of 64 consecutive vector data samples. Thus, when enabled, these 64 vector data samples are written into one local buffer 308.1-308.N (SBF) as a word (2048 bit wide), which is addressed by sbf_wr_ptr representing a write pointer as discussed herein. In this scenario, it is assumed that there are 8 such buffer words in the particular local buffer 308.1-308.N. The write into the local buffer 308 is thus word aligned, and therefore sbf_wr_ptr is only 3 bits. The sbf_wr_ptr field may thus represent a write pointer that identifies the starting location in the local buffer 308.1-308.N where data is to be written for further vector processing operations as discussed herein. The sbf_wr_enb field indicates, when enabled, that data is to be written into the local buffer 308.1-308.N (such as from the vector registers 302.1-30.N) as discussed herein. The fields sbf_rd_idx0, sbf_rd_idx1 may respectively represent read pointers identifying the starting location in the local buffer 308.1-308.N from which data is to be read, as discussed herein.
When enabled, the SBF read operation sbf_rd_enb results in an execution unit 304.1-304.N reading out two unaligned buffer words independently from a local buffer 308.1-308.N, which are indexed by sbf_r_idx0, sbf_r_idx1, respectively. These two 2048 bit words may be non-overlapped, partially overlapped, or completely-overlapped, depending on the values of sbf_r_idx0, sbf_r_idx1. To support such unaligned reads, both sbf_r_idx0 and sbf_r_idx1 are allocated 9 bits to be able to read from any 32 bit word position from the local buffer 308.1-308.N. These two read out buffer words are then sent to two sliding window creation (SWC) blocks to go through rotation/interleave-and-rotation and sliding window generation based on the filter types. Each SWC block generates four 32 component vectors, one for each filter coefficient. Usually, one SWC generates 4 vectors for a main data path, whereas the other SWC generates the other 4 vectors for the symmetric data path. Two main path vectors and two symmetric data path vectors are thus sent to a first multiplication block. The other two main path vectors and the other two symmetric data path vectors are sent to a second multiplication block.
Continuing this scenario, one vector is then read out from the on-chip LUT. Four 16 bit real or two 32 bit complex coefficients from the read out vector are cloned into two coefficient vectors. Each coefficient vector is fed to one multiplication block. The products from both multiplication blocks and the accumulation input F are then added together. The results are carried out by T.
Each execution of this operation may produce no filtered data sample (when only SBF write is enabled), 32, or 16 filtered data samples (when SBF read is enabled), depending on the filter type that is being implemented. After all filter coefficients have been applied to one set of data samples, the accumulated results are then processed through a shift-round-saturate (SRS) block to convert to a normal precision format. SRS is a common function in DSP for scaling fixed point data after arithmetic operations that result in data that no longer fits in the vector. Then, the data is packed into a packing register to wait for more samples. After 64 data samples are collected, filtered data sample processing is carried out by R and S. A and B represent pre-generated headers to control each filter operation.
The following dynamic fields are carried by A, B in each v_fir_filter operation:
The following fields are also used per-filter type, which may be loaded when no filter operation is performed (such as when sbf_wr_enb=1 and sbf_rd_enb=0).
Thus, the vector processing operations as discussed herein may be implemented using a for loop or other suitable control such that vector processing operations are iteratively executed, with the various fields for the vector processor instructions begin changed each pass through the for loop. Such fields thus dictate when data is to be written into the local buffers 308.1-308.N by each respective execution unit 304.1-304.N (sbf_wr_enb), the location within the local buffers 308.1-308.N where the data is to be written (sbf_wr_ptr), when data is to be read from the local buffers 308.1-308.N by each respective execution unit 304.1-304.N (sbf_rd_enb), the location within the local buffers 308.1-308.N from which the data is to be read (sbf_rd_idx0, sbf_rd_idx1, etc.), when data is to be written to the vector registers 302.1-302.N (mem_w_enb), etc.
As further discussed below, the device 800 may perform the functions as discussed herein with respect to the vector processor architecture 300 as shown and discussed with respect to
The processing circuitry 802 may be configured as any suitable number and/or type of computer processors, which may function to control the device 800 and/or other components of the device 800. The processing circuitry 802 may be identified with one or more processors (or suitable portions thereof) implemented by the device 800. The processing circuitry 802 may be identified with one or more processors such as a host processor, a digital signal processor, one or more microprocessors, graphics processors, baseband processors, microcontrollers, an application-specific integrated circuit (ASIC), part (or the entirety of) a field-programmable gate array (FPGA), etc.
In any event, the processing circuitry 802 may be configured to carry out instructions to perform arithmetical, logical, and/or input/output (I/O) operations, and/or to control the operation of one or more components of device 800 to perform various functions associated with the various techniques as described herein. The processing circuitry 802 may include one or more microprocessor cores, memory registers, buffers, clocks, etc., and may generate electronic control signals associated with the components of the device 800 to control and/or modify the operation of these components. The processing circuitry 802 may communicate with and/or control functions associated with the transceiver 804, the vector processor architecture 806, and/or the memory 808.
The transceiver 804 (when present) may be implemented as any suitable number and/or type of components configured to transmit and/or receive data packets and/or wireless signals in accordance with any suitable number and/or type of communication protocols. The transceiver 804 may include any suitable type of components to facilitate this functionality, including components associated with known transceiver, transmitter, and/or receiver operation, configurations, and implementations. Although depicted in
The memory 808 stores data and/or instructions such that, when the instructions are executed by the processing circuitry 802, cause the device 800 to perform various functions as described herein with respect to the vector processor architecture 806, such as controlling, monitoring, and/or regulating the flow of data through the vector processor architecture 806. The memory 808 may be implemented as any well-known volatile and/or non-volatile memory, including read-only memory (ROM), random access memory (RAM), flash memory, a magnetic storage media, an optical disc, erasable programmable read only memory (EPROM), programmable read only memory (PROM), etc. The memory 808 may be non-removable, removable, or a combination of both. The memory 808 may be implemented as a non-transitory computer readable medium storing one or more executable instructions such as, for example, logic, algorithms, code, etc.
As further discussed below, the instructions, logic, code, etc., stored in the memory 808 are represented by the various modules as shown, which may enable the functionally disclosed herein to be functionally enabled. Alternatively, the modules as shown in
The vector processing control engine 810 may represent the functionality described herein as discussed with reference to controlling and/or monitoring the vector processor architecture 806. The vector processing control engine 810 may represent the program memory 306 (and stored instruction sets), the decoder 320, and/or the vector data memory 301 as discussed herein with reference to
The executable instructions stored in the vector operation instruction management module 811 may facilitate, in conjunction with execution via the processing circuitry 802, the device 800 providing data streams and vector processor instructions to the vector processor architecture 806 (e.g. from a suitable data source as discussed herein). This may include a determination of a specific vector processor instruction to perform specific types of vector processing operations and/or any of the functionality as discussed herein with respect to the vector processor architecture 300 such as the calculation and storage of vector processing operation results. This may also include retrieving vector data samples from the vector registers 302.1-302.N.
The executable instructions stored in the vector processing data management module 813 may facilitate, in conjunction with execution via the processing circuitry 802, the determination of when the calculated results of vector processing operations are completed and stored in the appropriate buffer 308.1-308.N of an execution unit 304.1-304.N. This may include writing the results in one or more vector registers 304.1-304.N and/or sending the vector data sample results to the vector data memory 301 and/or the I/O data to be utilized by the appropriate components of the device 800 or other suitable device.
A vector processing unit is provided. With reference to
A system on a chip (SoC) is provided. With reference to
Flow 900 may begin when one or more processors retrieve (block 902) vector data samples from one or more of the vector registers 302.1-302.N and write (block 902) the retrieved vector data samples to a local buffer (such as one of buffers 308.1-308.N) associated with an execution unit 304.1-304.N.
Flow 900 may include one or more processors performing (block 904) vector processing operations on vector data samples read from a local buffer. This may include the use of a vector processor instruction that indicates a read pointer identifying the starting address location in the buffer from which the vector data samples are to be read.
Flow 900 may include one or more processors writing (block 906) the results of performing the vector processing operations on the read vector data samples to the buffer. This may include the use of a vector processor instruction that indicates a write pointer identifying the starting address location in the buffer to write the results of performing the vector processing operation. Again, any suitable number of vector processing operations may be performed via the use of subsequent vector processor instructions, as discussed with respect to
The following examples pertain to various techniques of the present disclosure.
An example (e.g. example 1) relates to a vector processing unit. The vector processing unit includes a buffer configured to store a set of vector data samples that are retrieved from one or more vector registers; and vector processing circuitry configured to: for a first vector processor instruction that is executed during a first one of a plurality of clock cycles, perform a first vector processing operation using a first portion of the stored set of vector data samples, for a second vector processor instruction that is executed during a second one of the plurality of clock cycles, perform a second vector processing operation using a second portion of the stored set of vector data samples, wherein a predetermined number of the first portion of the stored set of vector data samples used to perform the first vector processing operation are the same as the second portion of the stored set of vector data samples used to perform the second vector processing operation.
Another example (e.g. example 2) relates to a previously-described example (e.g. example 1), wherein the first vector processor instruction and the second vector processor instruction each includes a read pointer indicating a respective starting address location of the buffer from which the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples are read, respectively, to perform each respective first and second vector processing operation.
Another example (e.g. example 3) relates to a previously-described example (e.g. one or more of examples 1-2), wherein: the first vector processor instruction includes a first read pointer indicating a first starting address location of the buffer from which the first portion of the stored set of vector data samples are read, and the second vector processor instruction includes a second read pointer indicating a second starting address location of the buffer from which the second portion of the stored set of vector data samples are read, and the first starting address location and the second starting address location of the buffer are offset from one another by an address range that is less than an address range spanned by the set of vector data samples.
Another example (e.g. example 4) relates to a previously-described example (e.g. one or more of examples 1-3), wherein: the buffer comprises an input buffer and an output buffer, and the set of vector data samples retrieved from the one or more vector registers are stored in the input buffer, and results of the vector processing circuitry performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored in the output buffer.
Another example (e.g. example 5) relates to a previously-described example (e.g. one or more of examples 1-4), wherein the first vector processor instruction and the second vector processor instruction each includes a write pointer indicating a respective starting address location in the output buffer in which the results of the vector processing circuitry performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored.
Another example (e.g. example 6) relates to a previously-described example (e.g. one or more of examples 1-5), wherein the write pointer associated with the first vector processor instruction and the second vector processor instruction indicates the same starting address location in the output buffer.
Another example (e.g. example 7) relates to a previously-described example (e.g. one or more of examples 1-6), wherein the vector processor circuitry is configured to perform the first vector processing operation and the second vector processing operation without retrieving additional vector data samples from the one or more vector registers.
Another example (e.g. example 8) relates to a previously-described example (e.g. one or more of examples 1-7), wherein: the buffer comprises a further output buffer, the vector processing circuitry is configured to perform the first vector processing operation and the second vector processing operation as part of a plurality of vector processing operations associated with cascaded vector processing operation such that the vector processing circuitry is configured to, for a third vector processor instruction that is executed during a third one of a plurality of clock cycles, perform a third vector processing operation using one or more of a set of vector data samples that are read from the output buffer, with the results of the vector processing circuitry performing the third vector processing operation being stored in the further output buffer.
Another example (e.g. example 9) relates to a previously-described example (e.g. one or more of examples 1-8), wherein: the set of vector data samples are stored in the buffer over an address range, the buffer is configured, upon completion of the second vector processing operation, to overwrite the set of vector data samples stored in the address range with a further set of vector samples retrieved from the one or more vector registers, and the vector processing circuitry is configured to perform, for a third vector processor instruction that is executed during a third one of the plurality of clock cycles, a third vector processing operation by reading a portion of the further set of vector data samples stored in the buffer over the address range.
Another example (e.g. example 10) relates to a previously-described example (e.g. one or more of examples 1-9), wherein the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.
An example (e.g. example 11) relates to a system on a chip (SoC). The SoC includes a plurality of vector registers; and a plurality of vector processing units, each one of the plurality of vector processing unit comprising: a buffer configured to store a set of vector data samples that are retrieved from one or more of the plurality of vector registers; and vector processing circuitry configured to: for a first vector processor instruction that is executed during a first one of a plurality of clock cycles, perform a first vector processing operation using a first portion of the stored set of vector data samples, and for a second vector processor instruction that is executed during a second one of the plurality of clock cycles, perform a second vector processing operation using a second portion of the stored set of vector data samples, wherein a predetermined number of the first portion of the stored set of vector data samples used to perform the first vector processing operation are the same as the second portion of the stored set of vector data samples used to perform the second vector processing operation.
Another example (e.g. example 12) relates to a previously-described example (e.g. example 11), wherein the first vector processor instruction and the second vector processor instruction each includes a read pointer indicating a respective starting address location of the buffer from which the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples are read, respectively, to perform each respective first and second vector processing operation.
Another example (e.g. example 13) relates to a previously-described example (e.g. one or more of examples 11-12), wherein: the first vector processor instruction includes a first read pointer indicating a first starting address location of the buffer from which the first portion of the stored set of vector data samples are read, and the second vector processor instruction includes a second read pointer indicating a second starting address location of the buffer from which the second portion of the stored set of vector data samples are read, and the first starting address location and the second starting address location of the buffer are offset from one another by an address range that is less than an address range spanned by the set of vector data samples.
Another example (e.g. example 14) relates to a previously-described example (e.g. one or more of examples 11-13), wherein: the buffer comprises an input buffer and an output buffer, and
the set of vector data samples retrieved from the one or more vector registers are stored in the input buffer, and results of the vector processing circuitry performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored in the output buffer.
Another example (e.g. example 15) relates to a previously-described example (e.g. one or more of examples 11-14), wherein the first vector processor instruction and the second vector processor instruction each includes a write pointer indicating a respective starting address location in the output buffer in which the results of the vector processing circuitry performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored.
Another example (e.g. example 16) relates to a previously-described example (e.g. one or more of examples 11-15), wherein the write pointer associated with the first vector processor instruction and the second vector processor instruction indicates the same starting address location in the output buffer.
Another example (e.g. example 17) relates to a previously-described example (e.g. one or more of examples 11-16), wherein the vector processor circuitry is configured to perform the first vector processing operation and the second vector processing operation without retrieving additional vector data samples from the one or more vector registers.
Another example (e.g. example 18) relates to a previously-described example (e.g. one or more of examples 11-17), wherein: the buffer comprises a further output buffer, the vector processing circuitry is configured to perform the first vector processing operation and the second vector processing operation as part of a plurality of vector processing operations associated with cascaded vector processing operation such that the vector processing circuitry is configured to, for a third vector processor instruction that is executed during a third one of a plurality of clock cycles, perform a third vector processing operation using one or more of a set of vector data samples that are read from the output buffer, with the results of the vector processing circuitry performing the third vector processing operation being stored in the further output buffer.
Another example (e.g. example 19) relates to a previously-described example (e.g. one or more of examples 11-18), wherein: the set of vector data samples are stored in the buffer over an address range, the buffer is configured, upon completion of the second vector processing operation, to overwrite the set of vector data samples stored in the address range with a further set of vector samples retrieved from the one or more vector registers, and the vector processing circuitry is configured to perform, for a third vector processor instruction that is executed during a third one of the plurality of clock cycles, a third vector processing operation by reading a portion of the further set of vector data samples stored in the buffer over the address range.
Another example (e.g. example 20) relates to a previously-described example (e.g. one or more of examples 11-19), wherein the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.
An example (e.g. example 21) relates to a vector processing unit. The vector processing unit includes a buffer means for storing a set of vector data samples that are retrieved from one or more vector register means; and vector processing means for: for a first vector processor instruction that is executed during a first one of a plurality of clock cycles, perform a first vector processing operation using a first portion of the stored set of vector data samples, for a second vector processor instruction that is executed during a second one of the plurality of clock cycles, perform a second vector processing operation using a second portion of the stored set of vector data samples, wherein a predetermined number of the first portion of the stored set of vector data samples used to perform the first vector processing operation are the same as the second portion of the stored set of vector data samples used to perform the second vector processing operation.
Another example (e.g. example 22) relates to a previously-described example (e.g. example 21), wherein the first vector processor instruction and the second vector processor instruction each includes a read pointer indicating a respective starting address location of the buffer from which the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples are read, respectively, to perform each respective first and second vector processing operation.
Another example (e.g. example 23) relates to a previously-described example (e.g. one or more of examples 21-22), wherein: the first vector processor instruction includes a first read pointer indicating a first starting address location of the buffer means from which the first portion of the stored set of vector data samples are read, and the second vector processor instruction includes a second read pointer indicating a second starting address location of the buffer means from which the second portion of the stored set of vector data samples are read, and the first starting address location and the second starting address location of the buffer means are offset from one another by an address range that is less than an address range spanned by the set of vector data samples.
Another example (e.g. example 24) relates to a previously-described example (e.g. one or more of examples 21-23), wherein: the buffer means comprises an input buffer and an output buffer, and the set of vector data samples retrieved from the one or more vector register means are stored in the input buffer, and results of the vector processing circuitry performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored in the output buffer.
Another example (e.g. example 25) relates to a previously-described example (e.g. one or more of examples 21-24), wherein the first vector processor instruction and the second vector processor instruction each includes a write pointer indicating a respective starting address location in the output buffer in which the results of the vector processing means performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored.
Another example (e.g. example 26) relates to a previously-described example (e.g. one or more of examples 21-25), wherein the write pointer associated with the first vector processor instruction and the second vector processor instruction indicates the same starting address location in the output buffer.
Another example (e.g. example 27) relates to a previously-described example (e.g. one or more of examples 21-26), wherein the vector processor register performs the first vector processing operation and the second vector processing operation without retrieving additional vector data samples from the one or more vector register means.
Another example (e.g. example 28) relates to a previously-described example (e.g. one or more of examples 21-27), wherein: the buffer means comprises a further output buffer, the vector processing means performs the first vector processing operation and the second vector processing operation as part of a plurality of vector processing operations associated with cascaded vector processing operation such that the vector processing circuitry is configured to, for a third vector processor instruction that is executed during a third one of a plurality of clock cycles, perform a third vector processing operation using one or more of a set of vector data samples that are read from the output buffer, with the results of the vector processing means performing the third vector processing operation being stored in the further output buffer.
Another example (e.g. example 29) relates to a previously-described example (e.g. one or more of examples 21-28), wherein: the set of vector data samples are stored in the buffer means over an address range, the buffer means, upon completion of the second vector processing operation, overwrites the set of vector data samples stored in the address range with a further set of vector samples retrieved from the one or more vector registers, and the vector processing means performs, for a third vector processor instruction that is executed during a third one of the plurality of clock cycles, a third vector processing operation by reading a portion of the further set of vector data samples stored in the buffer means over the address range.
Another example (e.g. example 30) relates to a previously-described example (e.g. one or more of examples 21-29), wherein the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.
An example (e.g. example 31) relates to a system on a chip (SoC). The SoC includes a plurality of vector register means; and a plurality of vector processing units, each one of the plurality of vector processing unit comprising: a buffer means for storing a set of vector data samples that are retrieved from one or more of the plurality of vector register means; and vector processing means for: for a first vector processor instruction that is executed during a first one of a plurality of clock cycles, perform a first vector processing operation using a first portion of the stored set of vector data samples, and for a second vector processor instruction that is executed during a second one of the plurality of clock cycles, perform a second vector processing operation using a second portion of the stored set of vector data samples, wherein a predetermined number of the first portion of the stored set of vector data samples used to perform the first vector processing operation are the same as the second portion of the stored set of vector data samples used to perform the second vector processing operation.
Another example (e.g. example 32) relates to a previously-described example (e.g. example 31), wherein the first vector processor instruction and the second vector processor instruction each includes a read pointer indicating a respective starting address location of the buffer means from which the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples are read, respectively, to perform each respective first and second vector processing operation.
Another example (e.g. example 33) relates to a previously-described example (e.g. one or more of examples 31-32), wherein: the first vector processor instruction includes a first read pointer indicating a first starting address location of the buffer means from which the first portion of the stored set of vector data samples are read, and the second vector processor instruction includes a second read pointer indicating a second starting address location of the buffer means from which the second portion of the stored set of vector data samples are read, and the first starting address location and the second starting address location of the buffer means are offset from one another by an address range that is less than an address range spanned by the set of vector data samples.
Another example (e.g. example 34) relates to a previously-described example (e.g. one or more of examples 31-33), wherein: the buffer means comprises an input buffer and an output buffer, and the set of vector data samples retrieved from the one or more vector register means are stored in the input buffer, and results of the vector processing means performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored in the output buffer.
Another example (e.g. example 35) relates to a previously-described example (e.g. one or more of examples 31-34), wherein the first vector processor instruction and the second vector processor instruction each includes a write pointer indicating a respective starting address location in the output buffer in which the results of the vector processing means performing the first and the second vector processing operation on the first portion of the stored set of vector data samples and the second portion of the stored set of vector data samples, respectively, are stored.
Another example (e.g. example 36) relates to a previously-described example (e.g. one or more of examples 31-35), wherein the write pointer associated with the first vector processor instruction and the second vector processor instruction indicates the same starting address location in the output buffer.
Another example (e.g. example 37) relates to a previously-described example (e.g. one or more of examples 31-36), wherein the vector processor means performs the first vector processing operation and the second vector processing operation without retrieving additional vector data samples from the one or more vector register means.
Another example (e.g. example 38) relates to a previously-described example (e.g. one or more of examples 31-37), wherein: the buffer means comprises a further output buffer, the vector processing circuitry is configured to perform the first vector processing operation and the second vector processing operation as part of a plurality of vector processing operations associated with cascaded vector processing operation such that the vector processing circuitry is configured to, for a third vector processor instruction that is executed during a third one of a plurality of clock cycles, perform a third vector processing operation using one or more of a set of vector data samples that are read from the output buffer, with the results of the vector processing circuitry performing the third vector processing operation being stored in the further output buffer.
Another example (e.g. example 39) relates to a previously-described example (e.g. one or more of examples 31-38), wherein: the set of vector data samples are stored in the buffer means over an address range, the buffer means, upon completion of the second vector processing operation, overwrites the set of vector data samples stored in the address range with a further set of vector samples retrieved from the one or more vector registers, and the vector processing means performs, for a third vector processor instruction that is executed during a third one of the plurality of clock cycles, a third vector processing operation by reading a portion of the further set of vector data samples stored in the buffer means over the address range.
Another example (e.g. example 40) relates to a previously-described example (e.g. one or more of examples 31-39), wherein the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.
An apparatus as shown and described.
A method as shown and described.
The aforementioned description will so fully reveal the general nature of the disclosure that others can, by applying knowledge within the skill of the art, readily modify and/or adapt for various applications the techniques described herein without undue experimentation, and without departing from the general concept of the present disclosure. Therefore, such adaptations and modifications are intended to be within the meaning and range of equivalents of the disclosed techniques, based on the teaching and guidance presented herein. It is to be understood that the phraseology or terminology herein is for the purpose of description and not of limitation, such that the terminology or phraseology of the present specification is to be interpreted by the skilled artisan in light of the teachings and guidance.
References in the specification to “techniques,” “implementations,” etc., indicate that the implementation described may include a particular feature, structure, or characteristic, but every implementation may not necessarily include the particular feature, structure, or characteristic. Moreover, such phrases are not necessarily referring to the same implementation. Further, when a particular feature, structure, or characteristic is described in connection with an implementation, it is submitted that it is within the knowledge of one skilled in the art to affect such feature, structure, or characteristic in connection with other implementations whether or not explicitly described.
The implementations described herein are provided for illustrative purposes, and are not limiting. Other implementations are possible, and modifications may be made to the implementations as described herein. Therefore, the specification is not meant to limit the disclosure. Rather, the scope of the disclosure is defined only in accordance with the following claims and their equivalents.
The various techniques described herein may be implemented in hardware (e.g., circuits), firmware, software, or any combination thereof. The various techniques may also be implemented as instructions stored on a machine-readable medium, which may be read and executed by one or more processors. A machine-readable medium may include any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computing device). For example, a machine-readable medium may include read only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; flash memory devices; electrical, optical, acoustical or other forms of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.), and others. Further, firmware, software, routines, instructions may be described herein as performing certain actions. However, it should be appreciated that such descriptions are merely for convenience and that such actions in fact results from computing devices, processors, controllers, or other devices executing the firmware, software, routines, instructions, etc. Further, any of the implementation variations may be carried out by a general purpose computer.
For the purposes of this discussion, the term “processing circuitry” or “processor circuitry” shall be understood to be circuit(s), processor(s), logic, or a combination thereof. For example, a circuit can include an analog circuit, a digital circuit, state machine logic, other structural electronic hardware, or a combination thereof. A processor can include a microprocessor, a digital signal processor (DSP), or other hardware processor. The processor can be “hard-coded” with instructions to perform corresponding function(s) according to the various techniques as described herein. Alternatively, the processor can access an internal and/or external memory to retrieve instructions stored in the memory, which when executed by the processor, perform the corresponding function(s) associated with the processor, and/or one or more functions and/or operations related to the operation of a component having the processor included therein.
In one or more of the various techniques described herein, processing circuitry can include memory that stores data and/or instructions. The memory can be any well-known volatile and/or non-volatile memory, including, for example, read-only memory (ROM), random access memory (RAM), flash memory, a magnetic storage media, an optical disc, erasable programmable read only memory (EPROM), and programmable read only memory (PROM). The memory can be non-removable, removable, or a combination of both.
