Processor embedded streaming buffer

The present application is a continuation of U.S. patent application Ser. No. 17/358,218, filed on Jun. 25, 2021, which issued as U.S. Pat. No. 12,248,333 on Mar. 11, 2025, the contents of which are incorporated herein by reference in their entirety.

The disclosure described herein generally relates to array 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 array 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 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.

Vector Processing Operation

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.

1 2 FIGS.and 1 FIG. 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.provide two different implementations of a vector processor architecture.illustrates an attached vector processor, which is attached to a general purpose computer, for instance, for the purpose of enhancing and improving the performance of that computer in numerical computational tasks. The attached vector processor achieves high performance by means of parallel processing with multiple functional units, which may be alternatively referred to herein as execution units or processing units.

2 FIG. 2 FIG. 2 FIG. 2 FIG. 2 FIG. 200 204 1 204 204 1 204 204 1 204 200 201 204 1 204 201 200 201 202 1 202 204 1 204 202 1 202 , on the other hand, shows an example of a single instruction stream, multiple data streams (SIMD) vector processor. The vector processor architectureas shown inmay have an architecture consisting of one or more execution units. Each execution unit is capable of executing one instruction. Each instruction can be a control, load/store, scalar or a vector instruction. Therefore, a processor with N execution units.-.N as shown incan issue as many as N instructions every clock cycle. The execution units.-.N function under the control of a common control unit (such as processing circuitry), thus providing a single instruction stream to control each of the execution units.-.N. The I/O data as shown inis typically identified with data communicated between the vector processor architectureand another data source or processor (which may be the common control unit or another processor) depending upon the particular application. The vector data memorythus stores data received as input to be processed by the execution units.-.N, and data that is output or read from the vector data memoryafter the data is processed. The vector processor architectureas shown inis an example of a load-store architecture used by vector processors, which is an instruction set architecture that divides instructions into two categories: memory access (loading and storing data between the vector data memoryand the vector registers.-.N) and the vector processing operations performed by the execution units.-.N using the data retrieved from and the results stored to the vector registers.-.N.

201 202 1 202 204 1 204 202 1 202 201 204 1 204 206 200 204 1 204 202 202 1 202 204 1 204 2 FIG. 2 FIG. Thus, the load-store instruction architecture facilitates data stored in the vector data memorythat is to be processed to be loaded into the vector registers.-.N using load operations, transferred to the execution units.-.N, processed, written back to the vector registers.-.N, and then written back to the vector data memoryusing store operations. The location (address) of the data and the type of processing operation to be performed by each execution unit.-.N is part of an instruction stored as part of the instruction set in the program memory. 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 infor purposes of brevity. The interconnection network, which supports the transfer of data amongst the various components of the vector processor architectureas shown in, is generally implemented as a collection of data buses and may be shared among a set of different components, ports, etc. In this way, several execution units.-.N may write to a single vector register, and the data loaded into several vector registers.-.N may be read by and processed by several of the execution units.-.N.

200 200 202 1 202 2 FIG. The use of instruction sets in accordance with the vector processor architectureis 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 architectureas shown in, data reuse is achieved by storing the data in the vector registers.-.N, which has several drawbacks.

202 1 202 202 1 202 202 1 202 202 1 202 200 300 4 FIG.C 4 FIG.C 4 FIG.C 2 FIG. 3 FIG. One drawback of this scheme is that, to enable practical compiler design, the vector registers.-.N must be implemented with aligned access. This is illustrated inwith respect to a scenario in which the vector registers.-.N store 4-entry 8-word register files in an aligned manner, which are then read from the vector registers.-.N in an aligned manner to provide as 8-element (such as 8 vector data sample) result. In this scenario as shown in, the resister file stored in the vector registers.-.N is implemented as a 2D array of words. For such an approach, the vector data must reside entirely within the same entry of each element in the vector register file. However, it is common in many algorithms for the data to span across 2 or more entries of a register file as shown inand referred to as unaligned access. Conventional vector processors, such as the vector processor architectureas shown in, perform unaligned access by reading two vectors of data from the register files although there is only one vector of useful data, which is inefficient in terms of both cost and power. Another drawback is that convention processor architectures do not exploit the properties of streaming data applications, which is discussed in further detail herein with respect to the vector processor architectureas shown in.

204 1 204 202 1 202 3 FIG. Furthermore, it is common for several execution units.-.N to concurrently transfer data across the interconnection network to the vector register files.-.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. This increases efficiency as it enables each execution unit to locally access the contents of its own local buffer to execute a single instruction loop, which reduces the use of the interconnection network and also reduces power consumption.

Local Buffer Functionality

3 FIG. 3 FIG. 300 illustrates a vector processor architecture in accordance with the disclosure. The vector processor architecture as shown inmay be configured in accordance with any suitable type of vector processor application and implementation, which may utilize any suitable type of processor, CPU, etc. This may include standard, reduced instruction set computer (RISC), such as super scalar, very long instruction word (VLIW), graphics processing units (GPUs), etc. As noted further below, the vector processor architecturemay be implemented as part of a more specialized component such as a digital signal processor (DSP) and/or a radio transceiver that implement digital signal processing to perform filtering operations, which may include the application and/or calculation of digital pre-distortion (DPD) coefficients or terms, the application or calculation of digital filter taps or coefficients, etc.

200 300 302 1 302 304 1 304 300 301 302 1 302 304 1 304 302 1 302 302 1 302 2 FIG. 3 FIG. As noted above with reference to the vector processor architectureas shown in, the vector processor architectureas shown inmay also include any suitable number N of vector registers.-.N and execution units.-.N. The load-store machine architecture facilitates the vector processor architecturemoving data between the vector data memory, the vector registers.-.N, and the execution units.-.N. The vector registers.-.N may alternatively be referred to as vector register files, and may represent any suitable type of storage such as volatile or non-volatile memory, and which may have any suitable size, addressable space, and address configuration depending upon the size of the data samples that are loaded into the vector registers.-.N, which may be stored as data vectors in one or more vector register files, and which is typically a function of the particular instruction set and/or protocol such as vector size, word size, etc.

300 304 1 304 310 1 310 301 302 1 302 304 1 304 304 1 304 310 1 310 3 FIG. 3 FIG. The vector processor architecturemay also include any suitable number of execution units.-.N, which may implement any suitable type of vector processors, vector processing circuitry, etc., illustrated inas the processor circuitry.-.N, and which may be implemented to perform specific types of vector data processing operations based upon respectively received commands or instructions. These commands or instructions may originate from a decoder or other suitable processor that functions to arbitrate or otherwise schedule the processing of I/O data that is stored in the vector data memoryand transferred from the vector data memory to the vector registers.-.N using the interconnection network. The execution units.-.N may alternatively be referred to herein as vector units, vector processing units, or functional units, or further alternatively as execution unit circuitry, vector unit circuitry, vector processing unit circuitry, functional unit circuitry, or simply as one or more processors. The execution units.-.N may be implemented in accordance with any suitable type of vector processor architecture and include any suitable number and/or type of vector processing circuitry, as shown inas the processor circuitry.-.N, and which may include known vector processor architectures and/or types, to perform their respective vector processing operations.

304 1 304 304 1 304 310 1 310 304 1 304 304 1 304 300 Each of the execution units.-.N is configured to perform a specific type of mathematical operation via bit manipulation such as multiplication, addition, etc. Each of the execution units.-.N includes respective processor circuitry.-.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.-.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.-.N means that the vector processor architecturemay execute N number of instructions in parallel each clock cycle.

300 300 300 301 301 301 301 200 3 FIG. The vector processor architecturemay 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 architectureis implemented. That is, the vector processor architecturemay 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 memoryas shown inmay represent a SoC bus, which functions to write data to the vector data memoryand read data from the vector data memory. The communication between the vector data memoryand another entity using the SoC bus may be via Direct Memory access (DMA) or other suitable means. Thus, and as noted above for the vector processor architecture, the interconnection network may be a shared resource, and reducing the data transferred over the interconnection network thus reduces computational latency and power usage requirements.

200 304 1 304 308 1 308 308 1 308 304 1 304 310 1 310 304 1 304 308 1 308 308 1 308 308 1 308 302 1 302 308 1 308 310 1 310 308 1 308 304 1 304 308 1 308 310 1 310 308 1 308 300 2 FIG. 3 FIG. 3 FIG. 3 FIG. Therefore, in contrast to the vector processor architectureas shown in, each of the execution units.-.N as shown inincludes a buffer.-.N, which may be implemented as any suitable type of memory having suitable size, addressable space, and address configuration. The buffers.-.N may alternatively be referred to as streaming or circular buffers, with the functionality associated with these terms being further discussed herein. Each of the execution units.-.N also includes respective processor circuitry.-.N, which performs the aforementioned instructions and thus constitutes the portion of the execution units.-.N that interfaces with the streaming buffers.-.N, performs the requested vector processor instruction each clock cycle, and then writes the result back to a respective buffer.-.N as discussed in further detail below. The buffers.-.N may be implemented as memory of a size smaller than each of the vector registers.-.N, which may include a size just large enough to hold vector data samples until the vector data samples are fully processed. The connections between the buffers.-.N and each respective processor circuitry.-.N are not shown in detail infor purposes of brevity. However, because each buffer.-.N is local with respect to each execution unit.-.N, the data bandwidth between each buffer.-.N and its respective processor circuitry.-.N may be increased beyond the data bandwidth that would be available using the interconnection network, which represents an arbitrated and complex combination of shared data lanes. Furthermore, the use of the local buffers.-.N may facilitate the vector processor architectureas shown inimplementing vector processing operations using software-driven approaches in contrast to conventional vector processor architectures that require dedicated hardware that may be expensive, complex, and consume a great deal of power to perform vector processing operations.

308 1 308 302 1 302 308 1 308 304 1 304 302 1 302 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.-.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.-.N, the use of the local buffers.-.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.-.N. Again, transferring data to and from the vector registers.-.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.

308 1 308 300 308 1 308 308 1 308 300 300 320 308 1 308 310 1 310 304 304 1 304 304 1 304 320 3 FIG. It is also noted that the use of the buffers.-.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 architecturedescribed herein may leverage the use of the buffers.-.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.-.N as part of the vector processor architectureexploits 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 architectureas 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 decoderas shown in, and include a predetermined set of instructions or code, opcodes, etc. The vector processor instructions may include various types of commands, pointers to address locations in the buffers.-.N from which the processing circuitry.-.N is to read and write data, the particular type of mathematical function or vector processing operation that should be performed by a respective execution unitto which the vector instruction is sent, etc. Additional detail regarding the specific format and content of the vector processor instructions is discussed in further detail below. Each execution unit.-.N is configured to execute one or more vector processing operations per each received vector processor instruction, which may be sent to the execution units.-.N by the decodereach clock cycle in accordance with a common system clock.

308 1 308 308 1 308 300 308 1 308 402 404 302 1 302 400 450 308 1 308 402 404 4 4 FIGS.A-B 4 FIG.A 4 4 FIGS.A-B 3 FIG. 4 FIG.A The buffers.-.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.-.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 architectureand any suitable type of addressing scheme or organization may be implemented by the buffers.-.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. That is, and with reference to, the vector data sets,may represent any suitable number of vector data samples, and may constitute one or more data vectors that are retrieved from the vector registers.-.N. The buffers,as shown inmay thus be identified with any one of the buffers.-.N as discussed herein with reference to. Thus, the buffers or virtual buffers may be referred to as “circular,” meaning that vector data samples may be stored in a manner that “wraps” across the rows and/or columns of addressable space in an unaligned manner and may span the end of a particular addressable range (such as a range of addresses for a row) and the beginning of another addressable range (such as another row), as shown infor the vector data sets,.

4 FIG.A 4 FIG.A 406 408 308 1 308 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 inas the vector data samples,. The write pointers are shown inas being aligned with the starting row addresses of the two virtual buffers, although this is not a limitation and the buffers.-.N may receive vector processor instructions with write pointers to any starting vector address within the buffer or virtual buffer, as the case may be. However, it may be particularly advantageous to reserve a range of addresses within the virtual buffer as being dedicated for writing the results of performing the vector processing operations, or even reserving another separate virtual buffer for such results, as further discussed herein.

302 1 302 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.-.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.

300 308 1 308 302 1 302 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 processor architecturein 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.-.N may retrieve vector data samples from the vector registers.-.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.

308 1 308 308 1 308 302 1 302 452 454 450 4 FIG.B The use of the buffers.-.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.-.N in an unaligned manner and loaded into the vector registers.-.N using store operations. This is illustrated invia the use of the stored data vectors,being stored in the bufferacross different address ranges.

450 300 456 456 300 456 456 456 456 450 450 4 FIG.B 4 FIG.B 3 FIG. To adapt to the unaligned manner in which the vector data samples are stored in the buffer, the vector processor architecturemay include one or more data rotators such as the data rotator logicas shown in. Although a single data rotator logicis shown in, this is for purposes of brevity, and the vector processor architecturemay include any suitable number of data rotators depending upon the particular application and implementation. The data rotator logicis illustrated as having a specific size, but may be implemented having any suitable size depending upon a particular application. The data rotator logicmay be implemented using any suitable hardware components, software components, or combinations thereof. The data rotator logicmay be implemented as a Benes network or other suitable component using hardware. The data rotator logicis not shown infor purposes of brevity, but functions to align the vector data samples that are written to the bufferat the address indicated by a write pointer write_ptr as discussed herein, and read from the bufferin an unaligned manner at starting address locations as indicated by the read pointers read_ptr0 and read_ptr1. The starting address location of the read_pointers read_ptr0 and read_ptr1 may be part of a vector processor instruction and constitute respective read pointers as discussed herein.

4 FIG.B 4 FIG.C 4 FIG.C 4 FIG.C 452 454 450 452 454 450 461 450 462 450 450 illustrates a scenario in which 2 vectors,may be accessed from the buffer. The two vectors,may be used in two input vector operations such as a vector add or a vector multiply. Again, the starting position of each vector is indicated by read pointers to the starting address position in the bufferas indicated by read_ptr0 and read_ptr1, respectively. Thus, given a vector length of N elements (such as vector data samples), two sets of N sequential elements may be fetched starting from the respective read pointer positions and wrapping to the next consecutive row of the memory as needed. If a starting position of the read pointers point to word zero, then the vector access is aligned to the vector datapath as shown in the aligned access scenarioin. That is, element 0 of a vector is aligned with element 0 of a vector ALU or other suitable vector processor component in the vector datapath. However, if the position of the first element of a vector in the bufferdoes not point to element 0, then the access is unaligned. This is illustrated in the unaligned scenarioin, in which the first element of the vector is in position 3 of the buffer. In such a case, once the vector is read from the buffer, element 0 of the vector is in position 3 of the vector ALU, which would result in an incorrect computation. The vector thus needs to be rotated 3 positions as shown in the read result after rotation in the unaligned scenario in.

456 456 4 FIG.B Again, this alignment is achieved using the data rotator logicas shown in, which may include two or more data rotators. In this way, each of the 2 unaligned vectors may be independently rotated by each respective data rotator logicsuch that each vector becomes aligned to the arithmetic vector datapath. A similar approach may be used to write the resultant vector back to the buffer at any alignment. The following implementations as discussed herein may utilize such data rotation as needed, although this step may not explicitly be noted further herein for purposes of brevity.

462 450 304 1 304 302 1 302 456 302 1 302 456 450 320 4 FIG.C Thus, in contrast to the unaligned access from the 4-entry 8 word register file as shown in the unaligned access scenarioin, which requires retrieving all vector data samples from rows 1 and 2, the circular nature of the local bufferenables the execution units.-.N to read the vector data samples over an address range that includes these vector data samples and no additional vector data samples. This increases efficiency and power savings, as noted herein. The data rotation may be performed at any suitable time to ensure correct computations, and once aligned may then be stored in the vector registers.-.N. In this way, the data rotator logicre-aligns the vector data samples to ensure compatibility with standardized compilers and instruction sets that access the vector data samples from the vector registers.-.N in an aligned manner. The data rotator logicmay use information regarding the window offset and size of the stored data vectors to shift or realign the bits that are read from the bufferusing the read pointer address encoded into the vector processor instruction, and this may occur in a manner that is transparent to the compiler, the decoderor other component generating the vector processor instructions.

304 308 1 308 304 302 1 302 300 304 1 304 300 300 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's respective local buffer.-.N, which is retrieved by each respective execution unitfrom one or more of the vector registers.-.N in accordance with the received vector processor instruction. Such functions may be implemented as part of the particular application in which the vector processor architectureis 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.-.N of the vector processor architectureare provided in further detail in each Section below, although these are non-limiting scenarios as the vector processor architecturemay be implemented to in accordance with any suitable type of application and implementation, as noted above.

Digital Pre-Distortion (DPD) Vector Processing Operation Implementation

308 1 308 5 FIG. Again, the buffers.-.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), resulting in subsequent vector processing operations being performed re-using a portion of vector data samples from subsequent accessed vector data sets. This may be particularly useful to implement sliding window data access for certain types of vector processing operations. One such vector processing operation that leverages this type of sliding window processing includes the calculation of DPD terms or coefficients for a particular data stream. For such calculations, the function performed via the execution of each vector processing operation requires a different address offset within the data stream of retrieved vector data samples to compute a contribution to the output of the DPD term calculations.

5 FIG. 5 FIG. 5 FIG. 308 1 308 308 1 308 That is, and with reference now to, the buffer structure as shown may be identified with a portion of one or more of the buffers.-.N. In the illustrated scenario as shown in, it is assumed that the vector data samples used to perform each function or each vector processing operation have already been retrieved from one or more of the vector registers.-.N and loaded into the buffer. Moreover, a vector processing operation is performed each clock cycle on a set of vector data samples having a size of 64 samples. The progression of the functions 1 through 6 as shown incorresponds to 6 sequentially-executed vector processing operations, one per clock cycle and each performing a respective operation or function on 64 vector data samples stored in the buffer. The top and bottom progressions each illustrate a sequential order of sets of vector data samples being read or accessed from the buffer based upon the starting address location indicated by the vector processor instruction received each clock cycle. The top and bottom progressions show how the sets of vector data samples may follow different patterns sequentially based upon the read pointer indicated by each the vector processor instruction in each consecutive vector processing operation identifying different starting addresses.

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.

5 FIG. 5 FIG. 308 1 308 310 1 310 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, with each row containing 64 vector data samples and the buffer including 8 rows. The use of the read pointers and buffers.-.N facilitate the vector processing circuitry.-.N performing a vector processing operation in response to receiving a corresponding vector processor instruction that is executed during a clock cycle. This vector processing operation is performed using a first portion of the stored set of vector data samples that are read from the buffer (from a starting address as indicated by the read pointer included in the vector processor instruction), and which may be an entire row of vector data samples, i.e. 64 vector data samples associated with a range of addresses for a complete row as shown in the first step in each of the top and bottom scenarios as shown in.

310 1 310 304 1 304 302 1 302 5 FIG. 6 6 FIGS.A-K Then, for a subsequent clock cycle, the vector processing circuitry.-.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, and span a portion of the first row of 64 vector data samples and a portion of the next row of 64 vector data samples. Thus, between subsequent vector processing operations, some of each portion of the stored set of vector data samples are the same as one another, or re-used. In one scenario, this may include a predetermined number of each portion of the stored set of vector data samples are the same as one another, or re-used, which may be in accordance with the size of the data vectors and the particular application (such as the number of filter taps which may define a number of the vector data samples that are re-used). Thus, the scenario shown in further detail herein inmay re-use 7 of the 11 vector data samples between consecutive vector processing operations. Advantageously, several vector processing operations may be performed over several clock cycles without the need for the execution units.-.N to retrieve additional vector data samples from the vector registers.-.N. Again, this reduces the need to use the interconnection network between clock cycles, freeing up this resource, reducing power, and increasing the speed of computations.

Asymmetric Filter Vector Processing Operation Implementation

6 6 FIGS.A-K 300 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 toassume an 8-tap asymmetric filter implementation, although this is for illustrative purposes and not by way of limitation. The vector processor architecturemay perform vector processing operations in accordance with any suitable type of filter application or other applications, as noted herein.

308 1 308 300 6 6 FIGS.A-K 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.-.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, the vector processor architecturemay be implemented to perform such calculations by sequentially calculating a partial output of the FIR filter, or the contribution of a subset of the FIR filter taps, to the overall contribution of all FIR filter taps. This process may then be repeated until the output of each of the FIR filter taps for the set of coefficients for that particular filter are calculated, which may then be applied to an incoming data stream to realize the FIR filtering operation.

6 FIG.A 5 FIG. 6 6 FIGS.A-K 3 FIG. 308 1 308 600 308 1 308 304 1 304 600 600 600 600 602 1 604 1 604 2 604 3 604 4 600 602 2 606 1 606 2 6 6 3 606 4 Turning now to, as noted above, the buffers.-.N, may be further partitioned into any suitable number of virtual buffers and enable vector processing operations to be performed in a streaming manner to perform sliding time window computations, as noted above with respect toand the calculation of DPD terms. In the scenario as discussed in further detail with respect to, the bufferas shown may be identified with any one of (or each of) the buffers.-.N as shown in, which is identified with a respective execution unit.-.N. In this scenario, the bufferhas a total addressable range of 8 rows 0-7 and 16 columns 0-15. Each address location of the bufferis represented as an individual box of an intersecting row and column, and may store an individual vector data sample. The bufferis partitioned into two virtual circular buffers, each having a predetermined address range. The bufferincludes an input buffer., which has an address range identified with rows 6-7 and columns 0-15, and is thus configured to store a total of four data vectors.,.,.,., with each of these data vectors containing 8 vector data samples. The bufferalso includes an output buffer., which has an address range identified with rows 2-3 and columns 0-15, and which has an address range configured to store a total of four data vectors.,.,.,., with each of these data vectors containing 8 vector data samples.

602 1 602 2 602 1 302 1 302 302 1 302 602 1 602 2 6 6 FIG.A-K 6 6 FIGS.A-K The data samples represented by one or more data vectors stored in the input buffer.and the output buffer.may be referred to herein as a set of vector data samples. The sets of vector data samples stored in the buffer.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 todescribes a number of vector data samples identified with the number of data vectors retrieved from one or more of the vector registers.-.N in a single clock cycle. Thus, as used with respect to the non-limiting implementation as shown in, a set of vector data samples may include 16 total vector data samples, 8 per data vector, as two data vectors are retrieved from the vector registers.-.N in one clock cycle in this scenario. Of course, the input buffer.and the output buffer.may have any suitable size and accompanying address range, and thus may be configured to store any suitable number and any suitable size of vector data samples and/or otherwise store any suitable number of sets of vector data samples.

6 FIG.A 6 FIG.B 602 1 304 600 302 1 302 602 1 0 15 0 7 604 1 8 15 604 2 602 1 604 1 604 2 604 1 604 2 0 15 302 1 302 602 1 As shown in, the input buffer.is assumed to be initialized with zeros. In the next vector processing operation as shown in, the respective execution unitidentified with the bufferretrieves a set of vector data samples from one or more of the vector registers.-.N and loads (i.e. writes) the vector data samples into the input buffer.corresponding to the range of address at row 7, which are represented as the set of vector data samples X-X. In this illustrative scenario, the set of vector data samples X-X(data vector.) and X-X(data vector.) are written into the input buffer.during a single clock cycle for a single vector processor instruction, which constitutes the data vectors.,.. Thus, the vector processor instruction for this vector processing operation specifies that the two vectors.,.containing the set of vector data samples X-Xare to retrieved from the vector registers.-.N and written to the input buffer.starting at a specific buffer address indicated as row 7, column 0.

602 1 Although any suitable number of data vectors may be retrieved and loaded into the input buffer., 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.

6 FIG.C 6 FIG.C 0 10 602 1 0 3 0 10 602 1 0 7 0 10 602 1 0 0 3 1 1 4 602 2 602 2 0 7 0 10 602 2 During a subsequent vector processing operation as shown in, the vector processing operation computes the first 8 outputs of the FIR filter with respect to the contribution of the first 4 taps using the vector data samples X-X. The vector processor instruction for this vector processing operation thus contains the starting address as indicated by the read pointer, indicating the address location in the buffer.from which the vector data samples are to be retrieved, and the total number of vector data samples (11 in this case) to be retrieved to perform the computation as shown on the right side of. The multipliers H-Hare identified with the first four of the 8 FIR filter taps, which are multiplied and added with the vector data samples X-Xonce retrieved form the input buffer.. Due to the sliding time window processing as noted herein, each computed output Y-Yuses a set of 4 vector data samples X-Xretrieved from the input buffer.but shifted by one with respect to one another. That is, the output Yuses the vector data samples X-X, the output Yuses the vector data samples X-X, and so on. The vector processor instruction also includes a starting vector address location in the output buffer.as indicated by the write pointer and the total number of vector data samples (8 in this case) to be written to the output buffer.at this location. The computed results Y-Yof performing the vector processing operation on the vector data samples X-Xare stored in this range of addresses in the output buffer.(row 3, columns 0-7).

6 FIG.D 6 FIG.D 6 FIG.D 4 14 602 1 0 7 4 7 4 14 602 1 0 7 4 14 602 1 602 2 602 2 0 7 4 14 602 2 During a subsequent vector processing operation as shown in, the vector processing operation continues to compute the first 8 outputs of the FIR filter with respect to the contribution of the second 4 taps using the vector data samples X-X. The vector processor instruction for this vector processing operation thus contains the starting address as indicated by the read pointer, indicating the address location in the buffer.from which the vector data samples are to be retrieved (row 7, column 4), and the total number of vector data samples (11 in this case) to be retrieved to perform the computation on the right side of. The contribution of the first 4 filter taps was already computed and stored as the vector data samples Y-Y, and therefore the notation “+=” as shown inrepresents the remainder of the calculation for each of the first 8 outputs. This computation uses the filter taps H-H, which are identified with the second four of the 8 FIR filter taps, and these are multiplied and added with the vector data samples X-Xonce retrieved form the input buffer.. Again, due to the sliding time window processing as noted herein, each computed output Y-Yuses a set of 4 vector data samples X-Xretrieved from the input buffer.but shifted by one with respect to one another. Again, the vector processor instruction also includes a starting vector address location in the output buffer.as indicated by the write pointer and the total number of vector data samples (8 in this case) to be written to the output buffer.at this location. The computed results Y-Yof performing the vector processing operation on the vector data samples X-Xare stored at this range of addresses in the output buffer.(row 3, columns 0-7).

6 FIG.D 6 FIG.C 6 6 FIGS.C andD 6 6 FIGS.C andD 6 6 FIGS.C andD 6 6 FIGS.E andF 4 14 0 7 0 7 602 2 304 1 304 0 15 302 0 15 602 1 0 7 602 2 602 2 304 With reference to, the vector processing operation performed on the vector data samples X-Xresults in the partial results Y-Y, which may be accumulated with or added to the previous computation as discussed with respect to. Thus, after the two vector processing operations are performed as shown in, respectively, the contribution of the first 8 outputs of the FIR filter for all 8 taps is computed and represented by the vector data samples Y-Ystored in the output buffer.. In other words, the vector processor instruction used to instruct the relevant execution unit.-.N to perform the vector processing operation in each ofincludes loading the vector data samples X-Xfrom the vector registers, reading the appropriate vector data samples X-Xfrom the input buffer., performing the output contribution calculations Y-Y, and writing the results of the output contribution calculations to the output buffer.. Thus, two vector processing operations are used in this scenario to calculate a single data vector containing 8 vector data samples. It is noted that although the vector processor instructions for each of the vector processing operations performed in, respectively, result in the starting address location of the read pointer being incremented, the vector processor instructions for each of the vector processing operations may indicate the same write pointer starting address location in the output buffer.. However, and as shown in, the vector processor instruction used to instruct the relevant execution unitto perform the next vector processing operation for the next output of the 8 FIR filter taps may increment the write pointer address location by a number of addresses equal to the size of the vector data samples (8 in this case).

304 1 304 302 1 302 0 14 302 1 302 1 302 6 6 FIGS.C andD 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.-.N to retrieve additional vector data samples from the vector registers.-.N. This is also true in this implementation, as illustrated inby the vector processing operations being performed by retrieving the vector data samples X-Xfrom the input buffer.without the need to retrieve this data from the vector registers.-.N. This may be true for suitable umber of vector processing operations, and advantageously reduces the need to use the interconnection network between clock cycles.

6 FIG.E 8 18 304 1 304 600 604 3 604 4 302 1 302 602 2 16 31 16 23 604 3 24 31 604 4 602 1 604 3 604 4 604 3 604 4 16 31 302 1 302 602 1 During a subsequent vector processing operation as shown in, the vector processing operation computes the next (second) 8 outputs of the FIR filter with respect to the contribution of the first 4 taps using the vector data samples X-X. To do so, the respective execution unit.-.N identified with the bufferretrieves another set of vector data samples (two data vectors.,.in this scenario) from one or more of the vector registers.-.N and loads (i.e. writes) the vector data samples into the input buffer.corresponding to the range of address at row 6, which are represented as the set of vector data samples X-X. In this illustrative scenario, the set of vector data samples X-X(data vector.) and X-X(data vector.) are written into the input buffer.during a single clock cycle for a single vector processor instruction, which constitutes the data vectors.,.. Thus, the vector processor instruction for this vector processing operation specifies that the two vectors.,.containing the set of vector data samples X-Xare to retrieved from the vector registers.-.N and written to the input buffer.starting at a specific buffer address indicated as row 6, column 0.

6 FIG.E 6 FIG.E 6 FIG.E 8 18 602 1 0 3 8 18 602 1 602 2 602 2 8 15 8 18 602 2 8 18 602 1 During the subsequent vector processing operation as shown in, the vector processing operation computes the second 8 outputs of the FIR filter with respect to the contribution of the first 4 taps using the vector data samples X-X. The vector processor instruction for this vector processing operation thus contains the starting address as indicated by the read pointer, indicating the address location in the buffer.from which the vector data samples are to be retrieved (row 7, column 8), and the total number of vector data samples (11 in this case) to be retrieved to perform the computation on the right side of. Again, the multipliers H-Hare identified with the first four of the 8 FIR filter taps, which are multiplied and added with the vector data samples X-Xonce retrieved form the input buffer.. The vector processor instruction also includes a starting vector address location in the output buffer.as indicated by the write pointer and the total number of vector data samples (8 in this case) to be written to the output buffer.at this location. The computed results Y-Yof performing the vector processing operation on the vector data samples X-Xare stored at this range of addresses in the output buffer.(row 3, columns 8-15). Also, as shown in, the range of the vector data samples X--Xspans between the rows 6 and 7 of the input buffer..

304 1 304 602 1 15 16 18 602 1 602 2 602 1 602 2 602 1 602 2 The vector processor instruction indicates the location of the starting address using the read pointer, and the relevant execution unit.-.N may utilize the vector processor instructions together with knowledge regarding the range of addresses identified with the buffer.to retrieve the vector data samples in this manner, i.e. by “wrapping” around the range of vector address from Xat row 7 to continue to retrieve the remainder of the vector data samples X-Xat column 6. This wrapping feature is a function of the buffers.,.being implemented as circular in nature, and the particular manner in which vector data samples may be distributed across the input buffer.and the output buffer.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.and output buffer.to be particularly small.

602 1 6 FIG.D The read pointer as indicated by the vector processor instruction points to a vector address location in the input buffer.that is incremented or offset from the address location of the previous read pointer for the previous vector processing operation () by four, which is a result of the vector processing operations being performed for a set of four FIR filter taps at a time. Thus, the offset or increment made to the read pointer between vector processing operations is a function of the particular type of vector processing operation that is performed, and thus may be known to the compiler a priori and used to construct the vector processor instructions.

6 FIG.F 6 FIG.F 6 FIG.E 12 22 602 1 4 7 12 22 602 1 602 2 602 2 8 15 12 22 602 2 12 22 8 15 During a subsequent vector processing operation as shown in, the vector processing operation continues to compute the second 8 outputs of the FIR filter with respect to the contribution of the second 4 taps using the vector data samples X-X. The vector processor instruction for this vector processing operation thus contains the starting address as indicated by the read pointer, indicating the address location in the buffer.from which the vector data samples are to be retrieved (row 7, column 12), and the total number of vector data samples (11 in this case) to be retrieved to perform the computation on the right side of. The contribution of the second 4 filter taps uses the filter taps H-H, and these are multiplied and added with the vector data samples X-Xonce retrieved from the input buffer.. Again, the vector processor instruction also includes a starting vector address location in the output buffer.as indicated by the write pointer and the total number of vector data samples (8 in this case) to be written to the output buffer.at this location. The computed results Y-Yof performing the vector processing operation on the vector data samples X-Xare stored at this range of addresses in the output buffer.(row 3, columns 8-15). The vector processing operation performed on the vector data samples X-Xresults in the partial results Y-Y, which may be accumulated with or added to the previous computation as discussed with respect to.

6 6 FIGS.E andF 6 6 FIGS.E andF 8 15 602 2 304 1 304 16 31 302 8 22 602 1 8 15 602 2 Thus, after two additional vector processing operations are performed as shown in, respectively, the contribution of the second 8 outputs of the FIR filter for all 8 taps is computed and represented by the vector data samples Y-Ystored in the output buffer.. In other words, the vector processor instruction used to instruct the relevant execution unit.-.N to perform the vector processing operation in each ofincludes loading the vector data samples X-Xfrom the vector registers, reading the appropriate vector data samples X-Xfrom the input buffer., performing the output contribution calculations Y-Y, and writing the results of the output contribution calculations to the output buffer.as vector data samples. Thus, two vector processing operations are used in this scenario to calculate a single data vector containing 8 vector data samples.

602 1 602 2 16 30 602 2 16 23 6 6 FIGS.G andH This process of performing vector processing operations on the data read from the input buffer.and storing the results of the calculations in the output buffer.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, during two subsequent vector processing operations, the vector processing operations respectively compute the third 8 outputs of the FIR filter with respect to the contribution of the first and second 4 taps using the vector data samples X-X. The result of these calculations are then stored in an address range of the output buffer.identified with the vector data samples Y-Y.

602 1 602 2 602 1 602 1 0 15 304 1 304 302 1 3 2 602 1 602 1 32 47 6 FIG.G 6 FIG.F 6 FIG.G 6 FIG.G 6 6 6 FIGS.I,J, andK Another advantageous use of the input buffer.and the output buffer.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.beyond a predetermined address range. That is, and as shown in, the read pointer is now advanced to row 6 of the input buffer.. Thus, the entire address range of row 7, which previously contained the vector data samples X-X, are no longer needed for subsequent vector processing operations. Therefore, upon completion of the vector processing operation as shown in, the vector processing operation as shown inincludes the relevant execution units.-.N retrieving two new data vectors from the vector registers.-..N, the vector data samples of which are loaded into the input buffer.over a range of addresses associated with row 7 as shown in. Thus, the contents of this range of addresses in the input buffer.are overwritten with the new vector data samples X-Xfor future vector processing operations to be performed on these vector data samples (see).

6 6 FIGS.I andJ 6 FIG.G 24 38 32 38 0 15 602 2 24 32 Thus, during two subsequent vector processing operations as shown in, the vector processing operations respectively compute the fourth 8 outputs of the FIR filter with respect to the contribution of the first and second 4 taps using the vector data samples X-X, a portion of which (X-X) being part of the vector data samples overwritten to the previous vector data samples X-Xduring the previous vector processing operation (see). The result of these calculations are then stored in an address range of the output buffer.identified with the vector data samples Y-Y.

602 2 0 31 300 302 1 302 0 31 302 1 302 301 601 2 0 7 32 40 6 FIG.J 3 FIG. 6 FIG.K The output buffer.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, which are represented as Y-Y. The vector processor architecturemay transmit these vector data samples to another processor component, such as the vector registers.-.N, the I/O data, etc., which may be implemented by transferring, via a vector processor instruction, the vector data samples Y-Yto the vector registers.-.N, which may then be transferred to the vector data memoryas shown in. This may be triggered upon completion of one or more previous vector processing operations and/or by the vector processor instruction including a write pointer that has been incremented to point to a starting vector address in the output buffer.associated with a predetermined range of addresses (such as 8). In any event, it is assumed with respect tothat the previous vector data samples stored in the address range indicated by Y-Yare no longer needed and can be overwritten as subsequent vector processing operations are performed to calculate the new vector data samples Y-Y.

6 FIG.K 6 6 FIGS.C-I 601 1 602 2 Thus, and as shown in, the process of performing additional vector processing operations is continued, which may be repeated via the execution of the previous vector processing operations as discussed above with respect to. It is noted that the read and write pointers are now back to their original address locations with respect to the input buffer.and the output buffer., respectively. This is a result of the advancement of each of the read and write buffers over subsequent vector processing operations, as discussed herein.

Device Implementing Cascaded Processing

7 FIG. 3 FIG. 6 6 FIGS.A-K 308 1 308 illustrates the use of several circular buffers with a vector processor architecture to perform cascaded processing, in accordance with the disclosure. Again, the buffers.-.N as shown and discussed herein with respect tomay be divided or partitioned into any suitable number of virtual buffers, as discussed in further detail herein with respect to. This may be particularly advantageous when each buffer is dedicated for a specific type of vector processing function as part of a pipeline of cascaded processing operations. That is, similar to analog filtering, which may be performed in series and in several stages as part of known radio architectures, transceivers implementing digital filtering using DSP operations may do so by sequentially by applying stages of DSP operations on incoming data streams.

7 FIG. 7 FIG. 6 6 FIGS.A-K 700 308 1 308 702 1 702 700 702 1 702 4 0 1 2 300 Thus, and as shown in, the buffermay be identified with one or more of the buffers.-.N, and be partitioned into any suitable number of virtual buffers.-.N based upon the number of processing stages. In the illustration shown in, the bufferincludes a total of four virtual buffers.-., which accommodate three different processing stages to calculate the contribution of FIR filter taps to data streams in a sequential manner. Thus, each vector processing stage FIR, FIR, and FIRmay operate in a similar or identical manner as the asymmetric filter vector processing operations as shown and discussed herein with respect to. However, the actual calculations, number of taps, and/or filter coefficients may vary among the different FIR processing stages. Of course, the use of the filter processing stages is an illustrative and non-limiting scenario, as the vector processor architecturemay be used to perform any suitable type of vector processing operations on the vector data samples in a cascaded manner.

7 FIG. 0 1 2 702 1 702 4 702 1 702 4 702 1 602 1 302 1 302 702 1 702 2 602 2 0 702 1 702 2 702 3 702 4 602 1 602 2 1 702 2 702 2 0 702 1 0 702 2 1 1 702 2 702 2 1 702 3 As shown in, each FIR stage FIR, FIR, and FIRoperates on the vector data samples read from the respective buffer.-., which is output from the processing via the previous FIR processing stage. In other words, each of the virtual buffers.-.is a producer and consumer of streaming data, with the buffer.functioning as the input buffer.as discussed herein, which retrieves vector data samples from one or more of the vector registers.-.N that are written into an addressable range of the buffer.. The buffer.functions as the output buffer.as discussed herein, which stores the results of the FIRprocessing stage (i.e. the vector processing operations performed on the vector data samples stored in the buffer.). Thus, the buffers.,.,., etc. function as both the input buffer.and the output buffer.as discussed herein. That is, the FIR stage FIRretrieves the stored vector data samples from the buffer.that have been written to an address range of the buffer.via the FIR stage FIRperforming the vector processing operations on the vector data samples stored in the buffer.(which functioned as an output buffer for the FIR stage FIR), although the buffer.functions as an input buffer for the FIR stage FIRvector processing operations. The FIR stage FIRthen performs the relevant vector processing operations on the vector data samples stored in the buffer.(now functioning as an input buffer), performs the relevant vector processing operations on the vector data samples stored in the buffer., and then stores or writes the results of the vector processing operations associated with the FIR stage FIRto the buffer..

0 1 2 Thus, the vector processing operations may be cascaded or chained sequentially, with subsequent vector processing stages (such as FIR, FIR, FIR, 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.

304 1 304 310 1 310 304 1 304 302 1 302 302 1 302 308 1 308 308 1 308 308 1 308 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.-.N and/or the processor circuitry.-.N implemented by each of the execution units.-.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.-.N, a number of vector data samples to retrieve from the vector registers.-.N, a location from which the vector data samples are stored or written to the buffers.-.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.-.N, a location (such as a write pointer starting address location) in the buffers.-.N to write the results of performing the vector processing operations, etc.

6 6 FIGS.A-K 6 6 FIGS.A-K 304 1 304 308 1 308 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. In accordance with such a scenario, and as noted above, each instruction results in a specific execution unit.-.N reading a partial computation of the filtered data from an accumulator (a subset of taps computed in a previous instruction). The instruction computes the contribution of additional taps and adds the computation to the partially computed sum, with the partial results being written back to the accumulator, and the final results being written into one or more of the buffers.-.N as the two vector outputs (16 vector data samples) as discussed herein with respect to.

operation (<FU>, A, B, D, E, F, R, S, T); 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:

304 1 304 310 1 310 304 1 304 300 306 320 304 1 304 304 1 304 vec_filter(ctrl0, ctrl1, vec_in0, vec_in1, vec_acc_in, vec_out0, vec_out1, vec_acc_out). The vector processor instruction thus functions to instruct a corresponding execution unit.-.N that receives the vector processor instruction to perform a specific task. Thus, the vector processor instruction may be executed by the processing circuitry.-.N of a corresponding execution unit.-.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. The instructions illustrated in Table 1 below may form part of the instruction sets stored in the program memory, which may be generated by the decoderin accordance with a predetermined type of machine-readable code that is executed by the execution units.-.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.-.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:

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.

TABLE 1 Instruction Description ctrl: Instruction Control vec_in0: First vector of input samples vec_in1: Second vector of input samples vec_acc_in: Input vector of partially accumulated results coef_in: Subset of filter coefficients used in current stage vec_out0: First vector of filtered output data vec_out1: Second vector of filtered output data vec_acc_out: Output vector of partially accumulated results ctrl0[0:2]: Streaming buffer write index (write pointer) ctrl0[3]: streaming buffer write enable ctrl[4:12]: streaming buffer read 0 index (read pointer for vector 0) ctrl[13:21]: streaming buffer read 1 index (read pointer for vector 1) ctrl[22:27]: coefficient buffer read index ctrl[28]: 0 - 16-bit data, 1 - 32-bit data ctrl[28]: 0 - real data, 1 - complex data ctrl[30]: 0 - multiply, 1 - multiply accumulate

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. 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:

TABLE 2 Operand Direction C Type Width (bits) Cycle A Input unsigned int  32 0 B Input unsigned int  32 0 D Input _int1024 1024 0 E Input _int1024 1024 0 F Input _int2560 2560 4 R Output _int1024 1024 6 S Output _int1024 1024 6 T Output _int2560 2560 4

304 1 304 Such a vector processing instruction may represent a vector FIR filter operation processor instruction and be utilized by one of the execution units.-.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.

308 1 308 308 1 308 308 308 1 308 308 1 308 302 1 30 308 1 308 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.-.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.-.N. The write into the local bufferis 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.-.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.-.N (such as from the vector registers.-.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.-.N from which data is to be read, as discussed herein.

304 1 304 308 1 308 308 1 308 When enabled, the SBF read operation sbf_rd_enb results in an execution unit.-.N reading out two unaligned buffer words independently from a local buffer.-.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.-.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:

TABLE 3 Bit position Size Field Name Definition 1 sbf_wr_enb SBF write enable. when set, data carried in D, E is written into SBF. 1 sbf_rd_enb SBF read enable. When set, two SBF words are read out, filter operation is performed. 1 symm_enb When set, symmetric path is enabled. 9 sbf_rd_idx0 SBF read index 0 (read pointer for vector 0) 9 sbf_rd_idx1 SBF read index 1 (read pointe for vector 1) 1 pkr_enb When set, on-chip packing Register enabled. 1 pkr_we When set and pkr_enb = 1, one packing register is written. 1 pkr_idx Packing register Index. May increase to 2 bits. 1 pkr_pos Packing register position to indicate first 16 or second 16 position. May increase to 2 bits if 4-to-1 reduction is needed. 2 mac_type 0 - No accumulation 1 - Add accumulation input 2 - subtract accumulation input 3 - un-supported 3 sbf_wr_ptr SBF write index (write pointer) 1 mem_w_enb When set, data will be written into VMEM 5 output_fmt Specify the output format 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).

TABLE 4 Bit position Size Field Name Definition 4 fir_type FIR filter types 5 shift scalar shift value for SRS 1 sym_type 0 - symmetric 1 - anti-symmetric 2 mul_type 0 - MUL REAL, real numbers multiplication 1 - MUL CPX, complex numbers multiplication 2 - MUL SEMI, a real number times a complex number 3 - MUL MAGS, complex number magnitude square 1 mul_size 0 - 16 bit mode 1 - 32 bit mode 1 red_mode 0 - No reduction 1 - 2-to-1 reduction may need to increase to 2 bits 4 coef_Lut_idx Filter coefficient LUT index 5 coef_idx Filter coefficient component start index

308 1 308 304 1 304 308 1 308 308 1 308 304 1 304 308 1 308 302 1 302 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.-.N by each respective execution unit.-.N (sbf_wr_enb), the location within the local buffers.-.N where the data is to be written (sbf_wr_ptr), when data is to be read from the local buffers.-.N by each respective execution unit.-.N (sbf_rd_enb), the location within the local buffers.-.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.-.N (mem_w_enb), etc.

Device Implementing a Vector Processor Architecture

8 FIG. 3 FIG. 800 300 800 800 illustrates an example device, in accordance with the disclosure. The devicemay be identified with one or more devices implementing a vector processor architecture to perform vector processing operations, such as the vector processor architectureas shown and discussed herein with reference to. The devicemay be identified with a user equipment (UE) or other suitable device configured to perform wireless communications such as a mobile phone, a laptop computer, a cellular base station, a tablet, etc., which may include one or more components configured to transmit and receive radio signals, to perform digital signal processing, filter processing, DFE processing, etc. Alternatively, the devicemay be identified with a graphics processing unit (GPU), which may perform graphic processing on streams of graphical data.

800 300 800 800 802 804 806 808 800 804 800 3 FIG. 8 FIG. 8 FIG. As further discussed below, the devicemay perform the functions as discussed herein with respect to the vector processor architectureas shown and discussed with respect to. The devicemay perform vector processing operations using locally-implemented or embedded buffers to store vector data samples and the output of performing vector data processing on the stored vector data samples. To do so, the devicemay include processing circuitry, a transceiver, a vector processor architecture, and a memory. The components shown inare provided for ease of explanation, and the devicemay implement additional, less, or alternative components as those shown in. In one scenario, the transceivermay be omitted when the deviceis implemented as a GPU.

802 800 800 802 800 802 The processing circuitrymay be configured as any suitable number and/or type of computer processors, which may function to control the deviceand/or other components of the device. The processing circuitrymay be identified with one or more processors (or suitable portions thereof) implemented by the device. The processing circuitrymay 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.

802 800 802 800 802 804 806 808 In any event, the processing circuitrymay 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 deviceto perform various functions associated with the various techniques as described herein. The processing circuitrymay include one or more microprocessor cores, memory registers, buffers, clocks, etc., and may generate electronic control signals associated with the components of the deviceto control and/or modify the operation of these components. The processing circuitrymay communicate with and/or control functions associated with the transceiver, the vector processor architecture, and/or the memory.

804 804 804 804 804 804 804 804 804 806 806 300 8 FIG. 3 FIG. The transceiver(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 transceivermay 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 inas a transceiver, the transceivermay include any suitable number of transmitters, receivers, or combinations of these that may be integrated into a single transceiver or as multiple transceivers or transceiver modules. The transceivermay include components typically identified with an RF front end and include antennas, ports, power amplifiers (PAS), RF filters, mixers, local oscillators (LOs), low noise amplifiers (LNAs), upconverters, downconverters, channel tuners, etc. Thus, the transceivermay be configured as any suitable number and/or type of components configured to facilitate receiving and/or transmitting data and/or signals in accordance with one or more communication protocols. The transceivermay be implemented as any suitable number and/or type of components to support wireless communications such as analog-to-digital converters (ADCs), digital to analog converters, intermediate frequency (IF) amplifiers and/or filters, modulators, demodulators, baseband processors, etc. The data received via the transceiver(e.g. wireless signal data streams), data provided to the transceiverfor transmission (e.g. data streams for transmission), and/or data used in conjunction with the transmission and/or reception of data via the transceiver(e.g. digital filter coefficients) may be processed as data streams via the vector processor architecture, as discussed herein. Thus, the vector processor architecturemay be identified with the vector processor architectureas shown and described herein with reference to.

808 802 800 806 806 808 808 808 The memorystores data and/or instructions such that, when the instructions are executed by the processing circuitry, cause the deviceto perform various functions as described herein with respect to the vector processor architecture, such as controlling, monitoring, and/or regulating the flow of data through the vector processor architecture. The memorymay 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 memorymay be non-removable, removable, or a combination of both. The memorymay be implemented as a non-transitory computer readable medium storing one or more executable instructions such as, for example, logic, algorithms, code, etc.

808 808 800 802 8 FIG. 8 FIG. As further discussed below, the instructions, logic, code, etc., stored in the memoryare represented by the various modules as shown, which may enable the functionally disclosed herein to be functionally enabled. Alternatively, the modules as shown inthat are associated with the memorymay include instructions and/or code to facilitate control and/or monitor the operation of hardware components implemented via the device. In other words, the modules shown inare provided for ease of explanation regarding the functional association between hardware and software components. Thus, the processing circuitrymay execute the instructions stored in these respective modules in conjunction with one or more hardware components to perform the various functions as discussed herein.

810 806 810 306 320 301 306 320 301 802 808 3 FIG. 8 FIG. The vector processing control enginemay represent the functionality described herein as discussed with reference to controlling and/or monitoring the vector processor architecture. The vector processing control enginemay represent the program memory(and stored instruction sets), the decoder, and/or the vector data memoryas discussed herein with reference to. Additionally or alternatively, one or more of the program memory, the decoder, and/or the vector data memorymay form part of the processing circuitry, the memory, or separate components not shown in.

811 802 800 806 300 302 1 302 The executable instructions stored in the vector operation instruction management modulemay facilitate, in conjunction with execution via the processing circuitry, the deviceproviding data streams and vector processor instructions to the vector processor architecture(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 architecturesuch as the calculation and storage of vector processing operation results. This may also include retrieving vector data samples from the vector registers.-.N.

813 802 308 1 308 304 1 304 304 1 304 301 800 The executable instructions stored in the vector processing data management modulemay facilitate, in conjunction with execution via the processing circuitry, the determination of when the calculated results of vector processing operations are completed and stored in the appropriate buffer.-.N of an execution unit.-.N. This may include writing the results in one or more vector registers.-.N and/or sending the vector data sample results to the vector data memoryand/or the I/O data to be utilized by the appropriate components of the deviceor other suitable device.

General Operation of a Vector Processor Architecture

3 FIG. A vector processing unit is provided. With reference to, 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. 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.

3 FIG. A system on a chip (SoC) is provided. With reference to, 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. 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, 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. In addition or in alternative to and in any combination with the optional features previously explained in this paragraph, the first vector processing operation and the second vector processing operation each perform digital signal processing operations for wireless communications.

Process Flow

9 FIG. 9 FIG. 9 FIG. 9 FIG. 900 300 800 304 1 304 310 1 310 900 illustrates a process flow. With reference to, the flowmay be a computer-implemented method executed by and/or otherwise associated with one or more processors (processing circuitry) and/or storage devices. These processors and/or storage devices may be associated with one or more components of the vector processor architectureas discussed herein and/or one or more components of the deviceas discussed herein. The processors and/or storage devices may be identified with the one or more execution units.-.N and/or processor circuitry.-.N executing vector processor instructions. The flowmay include alternate or additional steps that are not shown infor purposes of brevity, and may be performed in a different order than the steps shown in.

900 902 302 1 302 902 308 1 308 304 1 304 Flowmay begin when one or more processors retrieve (block) vector data samples from one or more of the vector registers.-.N and write (block) the retrieved vector data samples to a local buffer (such as one of buffers.-.N) associated with an execution unit.-.N.

900 904 Flowmay include one or more processors performing (block) 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.

900 906 6 6 FIGS.A-K Flowmay include one or more processors writing (block) 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, such that vector processing operations may be executed on a data stream using the circular buffer architecture as discussed herein.

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.

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 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

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.