BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to the field of data processing and more particularly to central processing units.

2. Brief Description of the Prior Art

Sparse vectors are multi-operand vectors having zero or near zero operands removed and the remaining operands packed together. An apparatus for processing such vectors by a computer's central processing unit is disclosed in U.S. Pat. No. 3,919,534 to Hutson, et al. Such apparatus forwards operands to the arithmetic logic unit (ALU) from a given sparse vector one at a time. Zero operands are provided to the ALU only when a second sparse vector being input to the ALU for coprocessing has a non-zero operand in that order. An order vector is provided for each sparse vector to indicate by the state of a bit whether the correspondingly ordered sparse vector operand is zero or non-zero.

SUMMARY OF THE INVENTION

The present invention converts sparse vector format into unpacked format and forwards n-operands at a time to an n-wide arithmetic logic unit for tandem processing. In this manner, overall processing speed may be increased up to n times.

Unpacking is performed by inspecting the corresponding order vector n bits at a time. Operands are taken from the head of the sparse vector and positioned for each one-bit in the order vector. Zeros or a preselected operand value are inserted for each zero-bit in the order vector. A one-bit population count is performed on the n-bit segment of the order vector to control the moving of the sparse vector operands forward according to the count.

Selectively substituting all one-bits for the order vector at predetermined points in the logic allows the apparatus to expand a sparse vector into an expanded vector and/or compress a vector into a sparse vector.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a schematic of a circuit to expand a sparse vector for tandem procession by an ALU; and

FIG. 2 shows a schematic of a circuit to compress tandem resultants from an ALU into a sparse vector.

DESCRIPTION OF THE PREFERRED EMBODIMENT

FIG. 1 shows a schematic of the apparatus for unpacking a sparse vector for subsequent processing by an arithmetic logic unit (ALU). Normally, the ALU will coprocess two vectors at a time: adding, subtracting, multiplying or dividing them. The apparatus shown in FIG. 1 unpacks only one such vector. For processing two vectors, the apparatus of FIG. 1 is duplicated.

A typical vector has a number of operands in a specific order such as A₀, A₁, A₂, A₃ . . . , A_n. A sparse vector is a vector having certain predetermined operand values deleted. Normally, operands having a value of 0 or near 0 are deleted. The remaining operands are concatenated or packed for more efficient storage in memory and retrieval therefrom. For example, assume operands A₂, A₃ and A₈ of a given vector have the value of zero. That vector's sparse vector would appear in memory as A₁, A₄, A₅, A₆, A₇, A₉, . . . to A_n.

When performing an arithmetic operation with vectors, the corresponding order of operands of each vector must normally be simultaneously input to the ALU for processing. For example, when adding vector A to vector B, the corresponding order operands must be added, e.g., A₁ +B₁, A₂ +B₂, A₃ +B₃, . . . A_n +B_n.

As the sparse vectors located in memory do not have any inherent alignment information, i.e., the counting of five operands in from the first operand does not indicate operand A₄, each sparse vector must be provided with a corresponding order vector. An order vector consists essentially of a series of bits, one bit for each operand of a normal unpacked vector. The state of the bit is either zero or one. Zero indicates that the correspondingly ordered operand of the vector is deleted. One indicates that the correspondingly ordered operand of the vector is present. Only those operands corresponding to the one-bits, therefore, will be actually stored in memory.

In the prior art, such as with U.S. Pat. No. 3,919,534 to Hutson, et al., the order vector was inspected essentially one bit at a time. When a one-bit was encountered, the operand first in line was forwarded to the ALU for processing. But when a zero bit was encountered, an operand was not forwarded. With two vectors being simultaneously coprocessed, a one-bit in either order vector caused the forwarding of at least the operand from the sparse vector in which the order vector had a one-bit. If the other order vector had a zero-bit, a zero valued operand was inserted and forwarded instead of the operand at the head of the line.

The apparatus of FIG. 1 modifies this procedure by inspecting a group of eight order bits at a time. (In this regard, eight is an arbitrary number. The actual number of bits inspected can be arbitrarily chosen as may be appreciated by those skilled in the art.) Operands of a preselected value, such as zero are inserted into the operand stream coming from memory according to the occurrence of zeros in the order vector. The resulting expanded or unpacked eight operands are forwarded in parallel to the ALU for simultaneous tandem processing. An ALU such as found in the CDC CYBER 205 has the capability of processing eight operands in tandem.

If every bit of the order vector is a one signifying that eight non-zero operands are to be forwarded to the ALU, an increase in speed of up to eight times is achieved over the prior art method of forwarding one operand at a time to the ALU.

Sparse vector operands are fetched from memory by apparatus not shown and forwarded through interconnected eight-operand registers R1, R2 and R3, respectively, such that operands A₀ through A₇ (assuming in this example that the sparse vector has no zero valued operands) are located in R3, A₈ to A₁₅ in R2 and A₁₆ to A₂₃ in R1.

As the sparse vector operands are being loaded into registers R1 through R3, the sparse vector's corresponding order vector is loaded eight bits at a time into register X0. Each machine cycle, eight more bits are loaded into register X0 until all order vector bits have been loaded. Likewise, each machine cycle the contents of register X0 are copied by interconnected register X2 and also are provided as an input to a one-bit population counter EP1. The results of the population count, which may range from a count of 0 to a count of 8, are loaded into a four bit register X1 during the same machine cycle.

On the third machine cycle, the contents of register X2 are loaded into interconnected register X3. The four-bit count of register X1 is provided as one input to adder A1. The other input to adder A1 is provided by three bits from register SC1, which is initialized to a starting shift count determined by a programmer. A bias of 0 is provided as the fourth bit to this adder input. The three-bit output of adder A1 is loaded into three-bit register SC1 during the machine cycle. Also, a carry bit is loaded into carry register C1. The three-bit limitation on the adder's output provides that any addition having a result higher than the number seven has a carry input to carry register C1. The lower order three bits of a resultant are input to register SC1. Also during this machine cycle, interconnected register SC2 copies the contents of register SC1.

At the end of three machine cycles, register X3 contains the first group of eight bits of the order vector; SC1 has the three bit count of the number of 1 bits in that first group of order-vector bits plus the starting shift count, and register SC2 contains the starting shift count.

On the fourth machine cycle, the eight bits of register X3 are provided as inputs to expansion network E1. Also provided as inputs are eight outputs of shift network 10. The shift network receives fifteen operands: eight from register R3 and seven from R2. It shifts these operands to its eight outputs according to the count in register SC2, which on the fourth machine cycle contains the starting shift count. The expansion network E1 also receives preset data operands, normally a value of zero, from the preset data line. The expansion network arranges the two sets of operand inputs according to the arrangement of order vector bits contained in register X3.

For example, assume the starting shift count is zero and the initial eight bits of the order vector are 10011011, the leftmost list corresponding to A₀. Register R3 then contains in its lowest ordered cells sparse vector operands as follows:

A0, A3, A4, A6, A7 

R30, R31, R32, R33, R34.

The expansion network E1 inspects the lowest order bit from the order vector bits in X3 and, finding it to be a one, places operand A₀ from register R3 on its lowest order output. It inspects the next highest order bit from register X3 and, finding it to be a zero, places a preset data operand (0) on the second lowest order output, and so on, until the expansion network's eight outputs are as follows:

A0, O, O, A3, A4, O, A6, A7.

These eight outputs are simultaneously provided as inputs to the ALU for tandem processing.

During the next machine cycle, the fifth, the contents of register SC1, which is the count of the number of one-bits in the first group of eight order-vector bits, is loaded into register SC2. The output of register SC2 causes the shift network 10 to point to R3 cell address 5 for our example in which the number of one-bits in the first group of order-vector bits is five. By "point to", it is meant that the shift network shifts R3 cells 5, 6, and 7, and R2 cells 0, 1, 2, 3 and 4 into its eight outputs.

The second group of eight order bits is copied during this same machine cycle into register X3. Assuming the second group of order vector bits contains the following pattern: 01011101, the operands present in the shift network outputs (in part) will have originated from the fifth order R3 cell to the second order R2 cell as follows:

A9, A11, A12, A13, A15 

R35, R36, R37, R20, R21.

The expansion network E1 places these five operands on its outputs according to the pattern of order vector bits in register X3: 01011101. Thus the E1 outputs at the end of the fifth cycle will be O,A₉,O,A₁₁,A₁₂,A₁₃,O,A₁₅. These eight operands are forwarded in parallel for tandem coprocessing by the ALU.

The contents of SC1 in the previous machine cycle, cycle number four, was the number five reflective of five one-bits present in the first group of order vector bits. In addition to this count being loaded into SC2 for control of shift network 10, it is also fed back as the second input to adder A1, as explained supra. The second group of order-vector bits also had five one-bits. Thus the population counter EP1 will have forwarded a count of five to the first input to adder A1. The addition of these two count-of-five inputs causes the adder to place on its output the number 2 with a carry. The three lower most order bits have a bit-pattern 010 and are forwarded to the register SC1. The carry is forwarded to carry register C1.

During the fifth machine cycle, the presence of a 1 bit in the carry register causes register R3 to copy the contents of register R2, register R2 to copy the contents of register R1 and register R1 to load a new group of eight sparse vector operands.

Assuming the third and fourth groups of order vector bits are all ones, the contents of register R3 and R2, after this move, will appear as follows:

A13, A15, A16 . . . A29 

R30, R31, R32, . . . R27.

During this same machine cycle the contents of register SC1, 010, is loaded into register SC2. During the next machine cycle shift network 10 will thus point to R3₂, the second lowest order cell of register R3, which correctly contains the next sparse vector operand to be processed, A₁₆.

The process continues as such until each operand of the sparse vector has been forwarded to the ALU.

With more particularity, if the order vector inputs to expansion network E1 are denoted by Z₀, Z₁ . . . Z_n, the eight operand inputs from shift network 10 denoted by A, A₁, . . . A_n, the expansion network's outputs denoted by O₀, O₁, . . . O_n, and B=preset data, the following logic equations describe the operation of expansion network E1.

______________________________________     C00 = A0 --Z 0 + A1 Z.sub. 0     C10 = A1 --Z 0 + A2 Z.sub. 0     C20 = A2 --Z 0 + A3 Z.sub. 0     C30 = A3 --Z 0 + A4 Z.sub. 0     C40 = A4 --Z 0 + A5 Z.sub. 0     C50 = A5 --Z 0 + A6 Z.sub. 0     C60 = A6 --Z 0 + A7 Z.sub. 0     C01 = C00 --Z 1 + C10 Z.sub. 1     C11 = C10 -- Z1 + C20 Z.sub. 1     C21 = C20 --Z 1 + C30 Z.sub. 1     C31 = C30 --Z 1 + C40 Z.sub. 1     C41 = C40 --Z 1 + C50 Z.sub. 1     C51 = C50 --Z 1 + C60 Z.sub. 1     C02 = C01 --Z 2 + C11 Z.sub. 2     C12 = C11 --Z 2 + C21 Z.sub. 2     C22 = C21 --Z 2 + C31 Z.sub. 2     C32 = C31 --Z 2 + C41 Z.sub. 2     C42 =  C41 --Z 2 + C51 Z.sub. 2     C03 = C02 --Z 3 + C12 Z.sub. 3     C13 = C12 --Z 3 + C22 Z.sub. 3     C23 = C22 --Z 3 + C32 Z.sub. 3     C33 = C32 --Z 3 + C42 Z.sub. 3     C04 = C03 --Z 4 + C13 Z.sub. 4     C14 = C13 --Z 4 + C23 Z.sub. 4     C24 = C23 --Z 4 + C33 Z.sub. 4     C05 = C04 --Z 5 + C14 Z.sub. 5     C15 = C14 --Z 5 + C24 Z.sub. 5     C06 = C05 --Z 6 + C15 Z.sub. 6     O0 = B--Z 0 + A0 Z.sub. 0     O1 = B--Z 1 + C00 Z.sub. 1     O2 = B--Z 2 + C01 Z.sub. 2     O3 = B--Z 3 + C02 Z.sub. 3     O4 = B--Z 4 + C03 Z.sub. 4     O5 = B--Z 5 + C04 Z.sub. 5     O6 = B--Z 6 + C05 Z.sub. 6     O7 = B--Z 7 + C06 Z.sub. 7______________________________________

It will be recognized by those skilled in the art that the above logic equations may best be implemented bit by bit on the respective operands A and B.

The ALU receives the operands n pairs at a time and performs n arithmetic or logic operations thereon in tandem. After having performed these functions, the ALU outputs n resultants per machine cycle. Some of those resultants may have a value of zero or an invalid result in the case of a divide by zero. It is desirable to store these resultants in memory with the zero or invalid resultants deleted. The apparatus for performing such deletions is illustrated in FIG. 2.

Each machine cycle operands from a first expanded vector are stored in n-operand register R4. Likewise operands from a second expanded vector are stored in n-operand register R24. The ALU loads the operands from these registers, performs n tandem logical or arithmetic operations thereon and stores the n resultants in n-resultant register R5. These n resultants are then compressed into sparse vector format during the next machine cycle by compress network CR1, which will be hereinafter more fully described. The compressed resultants are stored in register R6. The number of resultants stored in R6 depends on the number of valid resultants (zero or invalid resultants deleted) present in the group of n resultants. These resultants are then forwarded to memory via downstream apparatus not shown.

The determination of which resultants are valid and which are zero or invalid is made according to a logical combination of the order vectors for the two sparse vectors, one of which is labeled the X order vector and the other of which is labeled the Y order vector. For example, if the operation to be performed on the two sparse vectors is an add or a subtract operation, the resultant vector will have a valid resultant for a given order whenever one of the input vectors had a valid operand in that order. If order vector X comprises 10000110 and order vector Y comprises 01001010, a resultant order vector Z will appear 11001110, a one corresponding to a valid resultant. This Z order vector is the logical "OR" of the X and Y order vectors. Likewise, if the operation is a multiply or a divide, the resultant order vector Z would appear 00000010, which is the logical "AND" of the X and Y order vector. Similar logical manipulation may be performed on the X and Y order vector to find a resultant order vector for any logical or arithmetic operation performed by the ALU.

In FIG. 2, this logical operation is performed in block SDO, which has as inputs the two operand order vectors X and Y, as well as an indication of the function or op-code to be performed by the ALU. Block SDO receives the two order vectors, eight bits each machine cycle, and stores the results in register X10.

Register X10 through X13 are delay registers which delay the resultant order vector Z the number of machine cycles as the input sparse vector operands need to pass through registers R1, R2, R3 and R4.

The output from register X13 is stored in register X14. But, as the transfer between these two registers occurs during the same period of time the operands are being processed by the ALU, the transfer is delayed by functional unit delay 20 to synchronize the arrival of Z order vector bits in X14 with the arrival of resultants in register R5. The time of the delay depends upon the logical or arithmetic operation being performed by the ALU.

The contents of register X14 are provided as one input to compress network CR1. They are also provided as the input to population counter CP1, which counts the number of one bits therein. This count, representative of the number of valid operands in R5, is forwarded to four-bit register X15. Register X15's output is provided to downstream circuitry to indicate the number of valid sparse vector resultants that are available in register R6 for storage in memory.

The operation of compress network CR1 is illustrated by the following example. Assuming the resultant order vector Z from register R14 comprises the bit pattern 10101101, the resultants present in register R5, r₀, r₁, r₂ . . . r₈ will be compressed and stored, left justified, into register R6 as follows: r₀, r₂, r₄, r₅, r₇, 0, 0, 0. r₁, r₃ and r₆, which correspond to zeroes in the Z order vector, have been deleted.

The logic equations for compress network CR1, where Z₀ through Z₇ represent resultant order vector bits input from register X14, A₀, A₁, A₂, . . . A₇ represent resultants input from register R5 and r₀, r₁, r₂ . . . r₇ represent the output of compress network CR1, comprise the following:

______________________________________   C70 = A7 Z7   C60 = A6 Z6   C50 = A5 Z5   C40 = A4 Z4   C30 = A3 Z3   C20 = A2 Z2   C10 = A1 Z1   C00 = A0 Z0   C71 = C70 Z6   C61 = C70 --Z 6 + C.sub. 60   C72 = C71 Z5   C62 = C71 --Z 5 + C61 Z.sub. 5   C52 = C61 --Z 5 + C.sub. 50   C73 = C72 Z4   C63 = C72 --Z 4 + C62 Z.sub. 4   C53 = C.sub. 62--Z 4 + C52 Z.sub. 4   C43 = C52 --Z 4 + C.sub. 40   C74 = C73 Z3   C64 = C73 --Z 3 + C63 Z.sub. 3   C54 = C63 --Z 3 + C53 Z.sub. 3   C44 = C53 --Z 3 + C43 Z.sub. 3   C34 = C43 --Z 3 + C.sub. 30   C75 = C74 Z2   C65 = C74 --Z 2 + C64 Z.sub. 2   C55 = C64 --Z 2 + C54 Z.sub. 2   C45 = C54 -- Z2 + C44 Z.sub. 2   C35 = C44 --Z 2 + C34 Z.sub. 2   C25 = C34 --Z 2 + C.sub. 20   C76 = C75 Z1   C66 = C75 --Z 1 + C65 Z.sub. 1   C56 = C65 --Z 1 + C55 Z.sub. 1   C46 = C55 --Z 1 + C45 Z.sub. 1   C36 = C45 --Z 1 + C35 Z.sub. 1   C26 = C35 --Z 1 + C25 Z.sub. 1   C16 = C25 --Z 1 + C.sub. 10   r7 = C77 = C76 Z0   r6 = C67 = C76 --Z 0 + C66 Z.sub. 0   r5 = C57 = C66 --Z 0 + C56 Z.sub. 0   r4 = C47 = C56 --Z 0 + C46 Z.sub. 0   r3 = C37 = C46 --Z 0 + C36 Z.sub. 0   r2 = C27 = C36 --Z 0 + C26 Z.sub. 0   r1 = C17 = C26 --Z 0 + C16 Z.sub. 0   r0 = C07 = C16.sup. --Z0 + C.sub.______________________________________   00

The above sets of equations imply the use of two-way OR's. The preferred embodiment actually uses four-way OR's. Those skilled in the art should modify the above equations when implementing the logic with four-way OR's to produce equivalent four-way OR logic.

While not illustrated, those skilled in the art will appreciate that a substitution of one-bits for the Z order vector bits will result in every resultant in register R5 being transferred undisturbed to register R6 and thence to memory. The resultant vector stored in memory under these circumstances would be in the expanded, uncompressed format. These one-bits may conveniently be introduced at register X10. If only one sparse vector is introduced and the ALU op-code is a NO-OP, the net result is that a sparse vector is converted to an expanded vector.

Likewise, if the vector or vectors in memory to be processed by the ALU are already in their expanded format (and maybe not even possessing an order vector), a group of one-bits input to register X₀ of FIG. 1 in lieu of the order vector bits results in no expansion in network EP1. In this manner, an expanded vector or vectors may be processed and compressed. If only one is input and the ALU op-code is a NO-OP, the net result is that the expanded vector is compressed into a sparse vector.

If one bits are substituted at both X0 and X10, one or more expanded vectors may be processed by the disclosed apparatus.

Other similar modifications are likely to occur to those skilled in the art.