fig1 depicts a high level view of the array processor machine organization . the machine organization is partitioned into three main parts : the system interfaces including global memory and external i / o , multiple control units with local memory , and the execution array with distributed control pes . the system interface is an application - dependent interface through which the array processor interfaces with global memory , the i / o , other system processors , and the personal computer / workstation host . consequently , the system interface will vary depending upon the application and the overall system design . the control units contain the local memory for instruction and data storage , instruction fetch ( i - fetch ) mechanisms , and operand or data fetch mechanisms ( d - fetch ). the execution array with distributed control pes is a computational topology of processing elements chosen for a particular application . for example , the array may consists of n processing elements ( pes ) per control unit , with each pe containing an instruction buffer ( ibfr ), a general purpose register file ( gprf ), functional execution units ( fns ), communication facilities ( com ), and interfaces to its instruction / data buses . the pes may also contain pe - local instruction and data memories . further , each pe contains an instruction decode register which supports distributed control of the multiple pes . synchronism of local memory accessing is a cooperative process between the control units , local memories , and the pes . the array of pes allows computation functions ( fns ) to be executed in parallel in the pes and results to be communicated ( com ) between pes . with the multiple simd machine organization , e . g . fig1 it is possible to create single or multiple thread machines wherein the topology of pes and communication facilities can be configured for a more optimum topology depending upon the application . for example , some possible machine organizations are ; multiple linear rings , a nearest neighbor 2 - dimension mesh array , a folded nearest neighbor 2 - dimension mesh , multiple - fold mesh , a 2 - dimension hexagonal array , a folded 2 - dimension hexagonal array , a folded mesh of trees , combinations of the above as well as others . fig2 depicts a generalized pe . the pe contains a com facility identified as the local interconnection switch network . this com facility provides the means for interfacing the gprf and the arithmetic elements with neighboring pes via the links . the com facility also provides the connecting interface to the control units local memory subsystem . the general philosophy of the instruction pipeline is for the control units , also termed sequence processors ( sps ), to access instructions and pass on to the pes any instructions designated to go there . this can be accomplished by use of the tagging of instructions . in a multiple pe organization there is a need to load single and multiple pes , store register / status registers from single pes to memory , and control the pes in different topologies . rather than proliferate opcodes to accomplish these tasks , tags are created and concatenated to the instructions for pe decode and control . tags operate as a mode control extension field to the instruction formats . by use of the vliw concept , the operating modes can be changed on a cycle by cycle basis if required . since the tag is generated from information stored in a special purpose register , its definition can be machine dependent allowing smaller tags for small machine organizations and larger tags for larger organizations . fig3 depicts a generic form for the tag . the instructions executed by the processing elements contain 32 bits plus a system dependent tag field . as an example , the instruction tag bits can convey specific status and mode information registered in the sp to the pes , as well as specific pe identifier values to support individual loading of the pes . all instructions are defined as broadcast operations going to all pes associated with a specific control unit &# 39 ; s instruction bus . specific tagged compute instructions are controlled by the tag field . if tagged compute is not specified all pes execute the instruction independent of the tag - code field . each pe is identified by a ring number , ring -# and a pe number , pe -#. this internal id number , id # can be used in conjunction with a tagged instruction to control the activity of the pes . both the instruction tag - code and instruction opcode are decoded during the decode phase of the pipeline and determine whether the execute phase for that instruction should be accomplished in each individual pe . in other words , the tag code operates as a mode control extension to the instruction opcode field . the allowable communications options are defined by the tag - code field , which precludes hazardous communication options . the programmer must set the operating mode which then is coded by the hardware into the tag . the tag - code is a scalable field that can change with the topology . for example , an 9 - bit tag could be created for a 2 × 2 array , a 12 - bit for a 4 × 4 , a 17 - bit for an 8 × 8 array , and other variations are possible . the general form of the implementation dependent instruction 4 × 4 - tag and 8 × 8 - tag are shown below : ( fig3 a ) in many processors , a three - phase fetch , decode , and execute pipeline is used for the basic instruction execution control where the instruction fetched is received in a single instruction decode unit . this requires that an instruction be fetched from one of n instruction memories and then be distributed to n sequencers and pes with both the sequencers and pes decoding and executing in synchronism the received instructions . depending upon topology size and the intended cycle time , the fetching and distributing of instructions can be accomplished in either a combined fetch / distribute cycle or in separate fetch and distribute cycles . for scalable topologies under consideration of 2 × 2 up to 10 × 10 it is envisioned that a combined fetch / distribute cycle is appropriate . in order to handle relatively high usage arithmetic conditional branch and pe generated exception conditional branch operations , a separate exception condition return phase is provided and two branch execution timings architectured . fig4 a and fig5 show two views of the four phase pipe ; fetch / distribute , decode , execute , and condition code return ( see table 1 ). table 1 shows a four phase instruction pipeline diagram example which is depicted in fig5 . fig4 b and fig6 depict a five phase pipeline for larger topologies with fast cycle times ( see table 2 ). table 2 shows a five phase instruction pipeline diagram example which is depicted in fig6 . unlike more conventional dsps , the sps and pes , both have facilities to register instructions , decode them , and execute them . thus , fig5 shows decode registers ( sdr and pdr ), decode logics , and execute registers ( sxr and pxr ) in the processing elements as well as the sequence processor . this approach is used for four reasons : 1 . it allows the maximum possible time in the paths from ( on - chip ) instruction memory to the sequencer , and from sequencer to pes . 2 . it makes it possible to minimize the number of signal wires in the busses used to distribute instructions from the sequencer to the pes . this is true because the instructions are distributed in coded ( short ) form rather than in decoded ( long ) form . 3 . it does not restrict the number of pes or their functional units . 4 . it allows the number of sequencers to be scaled in a consistent fashion with the scaling of the pe topology . names and abbreviations assigned to the instruction pipeline phases are as follows : __________________________________________________________________________abbreviation phase name and notes__________________________________________________________________________iag instruction address generation : a decision is made during the iag phase as to which instruction will be fetched next . at the end of the iag phase , the new instruction address is loaded into iar in the sequence processor . if instruction fetch : this function begins when the instruction address register iar ) is loaded with a new address . the instruction retrieved from instruction memory is delivered to the control unit on the instruction bus and latched into the instruction buffer register ( ibr ) at the end of the phase . dist instruction distribution : during the dist phase , the instruction in the ibr is distributed to the sequence processor decode register ( sdr ) and processing element decode register ( pdr ). if the system is in array mode , the instruction in ibr will be distributed to the decode registers in multiple sps and their associated pe rings . the phase ends when the buffered instruction is loaded into the various decode registers . if / dis instruction fetch / distribute : this function begins when the iar is loaded with a new address . the instruction retrieved from instruction memory is delivered to the sp on the instruction bus and is distributed to the sequence processor decode register ( sdr ) and processing element decode register ( pdr ). if the array mode is active , only one instruction memory source will drive the whole array while in ring mode four independent instruction sources each individually drive their rings of pes . the phase ends when the instruction is loaded into the various decode registers . dec instruction decode : during the decode phase , the tagged instruction previously latched into the sdr and pdr is decoded . if the instruction is to be executed by the sequence processor , an effective address may also be resolved in the sp during this phase . if the instruction to be executed has no action for the pe to perform , a forced nop is generated during this phase . at the end of this phase , the decoded instruction is latched into the sp execute register ( sxr ) and pe execute register ( pxr ). ex / com instruction execute : during this phase , the decoded instructions in the execute registers are executed and the results are communicated to the dest target registers . note that an instruction will execute in the sp and its associated pes at the same time . ccr condition code return : a condition code is returned from pes to the sequencer at the end of the ccr phase . __________________________________________________________________________ as an example , assume that there is an external video stream of luminance data providing pel data scan line by scan line with h pels per scan line . for example the first scan line is numbered p0 , 0 , p1 , 0 , . . . , ph - 1 , 0 . this video data is loaded sequentially into the global memory fig7 from the global memory the data for an 8 × 8 block is loaded into the local data memory fig7 . from local data memory the 8 × 8 block fig1 a is loaded into the array fig1 b . the pe indexed load instruction ( peil ) is used to accomplish the loading . in the example presented , fig8 the base register rb = 1 is initially set to the address ( block x ). the ri / ru increment / update register is set to zero , the immediate field is set to a 1 , and the trgt register in the pes is set to r0 ( 0 ). two types of peil instructions are used , as specified in the opx extended opcode field , to specify the byte loading pattern into the trgt pe register . array mode is specified , and , for example purposes , the instruction i - bus and data d - bus switches are set as follows : the following four instructions loads the 8 × 8 64 - pels , 8 - bits / pel , into the processor . in array mode the peil instruction will cause a 16 - byte load to occur , one 4 - byte load from each data memory . the results of each peil instruction is shown in fig9 parts a , b , c , and d . a larger sized diagram including the 8 × 8 pel array is depicted in fig1 . tagged loads require the pes to check whether the received instruction tag field matches the ring #/ pe # stored in each pes prior to execution . if a matching tag is not found a nop is executed . tagged stores require the pes to check whether the received instruction tag field matches the ring #/ pe # stored in each pes prior to execution . if a matching tag is not found a nop is executed . ( ox3 is a 2 - bit opcode extension field . the condition / status register in each pe is identified in the following table by c / s .) fig1 shows the sequencer processor / processor element tagged load word instructions for load pe register , direct addressed load , displacement addressed load , indexed addressing , and sp - ri register utilization . table 3 shows indexed processor element load variants , and table 4 shows tagged load variants . fig1 shows the sequencer processor / processor element tagged store word instructions for store pe register , direct addressed store , displacement addressed store , indexed addressing , and sp - ri register utilization . table 5 shows indexed pe load variants , table 6 shows tagged store variants . the use of a combined fetch / distribute sequence provides a low latency pipeline . 2 . provide single source synchronization control for a scalable simd array of processing elements , the control unit bus provides a means for single source synchronization . 3 . allow for programmable reconfigurability of the scalable array into multiple smaller independent arrays the use of a sequencer per independent array along with the control unit bus provides a programmable means for reconfiguration . 4 . provide each of the smaller arrays with their own source synchronization control , 5 . provide reconfigurable memory resources where all resources are available for the single simd array and the resources are equally partitioned to the other smaller arrays , by passing single simd thread control between the multiple sequencers allows use of all resources in the single simd array mode . 6 . provide synchronized control for joint operations between the control units and their processing elements , with distributed and parallel decode of instructions in the pes and sequencers , joint pe / sequencer control is easily provided . 7 . provide single pe , combination of pes , single ring , and combination of rings control for loading , storing , and arithmetic control . tagging instructions allows individual pe and combination of pe control for loading , storing , and arithmetic operations . 8 . and provide a single control unit design that is replicatable supporting the scalable design requirement . the number of control units or sequencers is scalable through use of the control unit bus . two mode control registers 207 are provided in each pe 120 to control the basic operational modes in the pes . the first mode control register contains configuration bits , i - bus switch , d - bus switch , nearest - neighbor / adjacent - pe communications mode , and ring / array mode . the second mode control register contains arithmetic options for rounding and saturation control of specific execution unit results . two pe instructions control the loading of the two registers . the pe set mode instruction shown in fig1 controls the configuration bits and loads all pes with immediate mode control information contained in the instruction . the pe set rounding / saturation instruction loads the second register . for the configuration mode register , the i - bus switches are controlled from this mode register which specifies in the dual pes how the two ia / ib bus ports and the two da / db bus ports are connected to the top and bottom pe . using these switch settings and by connecting the i0 , i1 , i2 , i3 and d0 , d1 , d2 , d3 buses as shown in fig1 , the i - buses and d - buses can be connected to the row pes , the column pes , or asymmetric groupings of pes . additional mode bits indicate whether the pes are in a nearest neighbor or adjacent - pe communications mode . mode information must also be provided for how the pe - to - pe interface is to be used when independent row rings or column rings are used , since the nearest neighbor / adjacent - pe interface is modified accordingly . the following lists the operational mode bit definitions . 01 = 1a - bus port connects to the top pe and the bottom pe , 1b - bus port not connected 10 = 1b - bus port connects to the top pe and the bottom pe , 1a - bus port not connected 01 = da - bus port connects to the top pe and the bottom pe , db - bus port not connected 10 = db - bus port connects to the top pe and the bottom pe , da - bus port not connected a load offset register instruction provides byte loading of the pe &# 39 ; s offset register . for conditional move operations and future extensions , a 32 - bit test register is provided in each pe which can be used to load any register value from the register file and store any value back . no operations are defined to use this register . it is used by conditional move logic . if no conditional moves are used it represents an additional storage space for program use . although a specific embodiment of the invention has been disclosed , it will be understood by those having skill in the art that changes can be made to the specific embodiment without departing from the spirit and the scope of the invention . table 1______________________________________4 - phase instruction pipeline diagram exampleiarvalue if / dist dec ex / com ccr______________________________________i i ( i ) i + 2 i ( i + 2 ) i ( i + 1 ) i ( i ) i + 3 i ( i + 3 ) i ( i + 2 ) i ( i + 1 ) i ( i ) i + 4 i ( i + 4 ) i ( i + 3 ) i ( i + 2 ) i ( i + 1 ) ______________________________________ a diagram of this flow is shown in fig5 table 2______________________________________5 - phase instruction pipeline diagram exampleiarvalue if dist dec ex / com ccr______________________________________i i ( i ) i + 2 i ( i + 2 ) i ( i + 1 ) i ( i ) i + 3 i ( i + 3 ) i ( i + 2 ) i ( i + 1 ) i ( i ) i + 4 i ( i + 4 ) i ( i + 3 ) i ( i + 2 ) i ( i + 1 ) i ( i ) i + 5 i ( i + 5 ) i ( i + 4 ) i ( i + 3 ) i ( i + 2 ) i ( i + 1 ) ______________________________________ table 3__________________________________________________________________________indexed pe load variantstype effective address used description__________________________________________________________________________1 ea = rb + ri ( h0 ); increment immediate ri ( h0 ) ← ri ( h0 ) + s .. s , imm 4 - b immediate sign extended to 16 bits or , ea = rb + ri ( h0 ) ( when imm = 0 ) 2 ea = rb + ri ( h0 ); circular immediate indexing ri ( h0 ) ← ( ri ( h0 ) + ri ( h1 )) mod imm ri ( h0 ) ← ri ( h0 ) + ri ( h1 ) ( when imm = 0 ) 3 ea = rb + ri ( h0 ); circular register indexing ri ( h0 ) ← ( ri ( h0 ) + ri ( b2 )) mod ri ( b3 ) ri ( h0 ) ← ri ( h0 ) + ri ( b2 ) ( when ri ( b3 ) = 0 ) __________________________________________________________________________ table 5__________________________________________________________________________indexed pe load variantstype effective address used description__________________________________________________________________________1 ea = rb + ri ( h0 ); increment immediate ri ( h0 ) ← ri ( h0 ) + s .. s , imm 4 - b immediate sign extended to 16 bits or , ea = rb + ri ( h0 ) ( when imm = 0 ) 2 ea = rb + ri ( h0 ); circular immediate indexing ri ( h0 ) ← ( ri ( h0 ) + ri ( h1 )) mod imm ri ( h0 ) ← ri ( h0 ) + ri ( h1 ) ( when imm = 0 ) 3 ea = rb + ri ( h0 ); circular register indexing ri ( h0 ) ← ( ri ( h0 ) + ri ( b2 )) mod ri ( b3 ) ri ( h0 ) ← ri ( h0 ) + ri ( b2 ) ( when ri ( b3 ) = 0 ) __________________________________________________________________________ table 4__________________________________________________________________________tagged load variants effective addressopcodeox3 used execute function performed__________________________________________________________________________xxxxxx0 ?? sp - src if tags match ; then r ( trgt @ rit / ape ) ← sp - src else nop load 1 or multiple pes ( ape ) in ring # ( rit ) xxxxxx0 ?? sp - src if tags match ; then r ( trgt @ pet / ari ) ← sp - src else nop load a pe ( pet ) in 1 or multiple rings ( ari ) xxxxxx1 ?? ea = imm if tags match ; then r ( trgt @ rit / ape ) ← sp - mem ( ea ) else nop load 1 or multiple pes ( ape ) in ring # ( rit ) xxxxxx1 ?? ea = imm if tags match in each ring ; then for each ring r ( trgt @ pet / ari ) ← ring ( ari )/ sp - mem ( ari )( ea ) else nop in each ring load a pe ( pet ) in 1 or multiple rings ( ari ) xxxxxx2 ?? ea = rb + s .. s , dsp if tags match ; then r ( trgt @ rit / ape ) ← sp - mem ( ea ) else nop load 1 or multiple pes ( ape ) in ring # ( rit ) xxxxxx2 ?? ea = rb + s .. s , dsp if tags match in each ring ; then for each ring r ( trgt @ petiari ) ← ring ( ari )/ sp - mem ( ari )( ea ) else nop in each ring load a pe ( pet ) in 1 or multiple rings ( ari ) xxxxxx3 ?? ea = type - 1 if tags match ; then r ( trgt @ rit / ape ) ← sp - mem ( ea ) else nop load 1 or multiple pes ( ape ) in ring # ( rit ) xxxxxx3 ?? ea = type - 1 if tags match in each ring ; then for each ring r ( trgt @ pet / ari ) ← ring ( ari )/ sp - mem ( ari )( ea ) else nop in each ring load a pe ( pet ) in 1 or multiple rings ( ari ) xxxxxx4 ?? ea = type - 2 if tags match ; then r ( trgt @ rit / ape ) ← sp - mem ( ea ) else nop load 1 or muitiple pes ( ape ) in ring # ( rit ) xxxxxx4 ?? ea = type - 2 if tags match in each ring ; then for each ring r ( trgt @ pet / ari ) ← ring ( ar1 )/ sp - mem ( ari )( ea ) else nop in each ring load a pe ( pet ) in 1 or muitiple rings ( ari ) xxxxxx5 ?? ea = type - 3 if tags match ; then r ( trgt @ rit / ape ) ← sp - mem ( ea ) else nop load 1 or multiple pes ( ape ) in ring # ( rit ) xxxxxx5 ?? ea = type - 3 if tags match in each ring ; then for each ring r ( trgt @ pet / ari ) ← ring ( ari )/ sp - mem ( ari )( ea ) else nop in each ring load a pe ( pet ) in 1 or multiple rings ( ari ) __________________________________________________________________________ table 6__________________________________________________________________________tagged store variants effective addressopcodeox3 used execute function performed__________________________________________________________________________xxxxxx000 pe - src if tags match ; then sp - trgt ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in spxxxxxx001 sp - src if tags match ; then sp - trgt ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( rit ) c / s in spxxxxxx100 ea = imm if tags match ; then sp - mem ( ea ) ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in memxxxxxx101 ea = imm if tags match ; then sp - mem ( ea ) ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( rit ) c / s in memxxxxxx110 ea = imm ring - 0 / sp - mem - 0 ( ea ) ← r ( trgt @ ring - 0 / pet ) ring - 1 / sp - mem - 1 ( ea ) ← r ( trgt @ ring - 1 / pet ) ring - 2 / sp - mem - 2 ( ea ) ← r ( trgt @ ring - 2 / pet ) ring - 3 / sp - mem - 3 ( ea ) ← r ( trgt @ ring - 3 / pet ) xxxxxx200 ea = rb + s .. s , dsp if tags match ; then sp - mem ( ea ) ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in memxxxxxx201 ea = rb + s .. s , dsp if tags match ; then sp - mem ( ea ) ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( rit ) c / s in memxxxxxx210 ea = rb + s .. s , dsp ring - 0 / sp - mem - 0 ( ea ) ← r ( trgt @ ring - 0 / pet ) ring - 1 / sp - mem - 1 ( ea ) ← r ( trgt @ ring - 1 / pet ) ring - 2 / sp - mem - 2 ( ea ) ← r ( trgt @ ring - 2 / pet ) ring - 3 / sp - mem - 3 ( ea ) ← r ( trgt @ ring - 3 / pet ) xxxxxx300 ea = type - 1 if tags match ; then sp - mem ( ea ) ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in memxxxxxx301 ea = type - 1 if tags match ; then sp - mem ( ea ) ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( rit ) c / s in memxxxxxx310 ea = type - 1 ring - 0 / sp - mem - 0 ( ea ) ← r ( trgt @ ring - 0 / pet ) ring - 1 / sp - mem - 1 ( ea ) ← r ( trgt @ ring - 1 / pet ) ring - 2 / sp - mem - 2 ( ea ) ← r ( trgt @ ring - 2 / pet ) ring - 3 / sp - mem - 3 ( ea ) ← r ( trgt @ ring - 3 / pet ) xxxxxx400 ea = type - 2 if tags match ; then sp - mem ( ea ) ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in memxxxxxx401 ea = type - 2 if tags match ; then sp - mem ( ea ) ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( r ( t ) c / s in memxxxxxx410 ea = type - 2 ring - 0 / sp - mem - 0 ( ea ) ← r ( trgt @ ring - 0 / pet ) ring - 1 / sp - mem - 1 ( ea ) ← r ( trgt @ ring - 1 / pet ) ring - 2 / sp - mem - 2 ( ea ) ← r ( trgt @ ring - 2 / pet ) ring - 3 / sp - mem - 3 ( ea ) ← r ( trgt @ ring - 3 / pet ) xxxxxx500 ea = type - 3 if tags match ; then sp - mem ( ea ) ← r ( pe - src @ rit / pet ) else nop store pe #( pet ) ring #( rit ) in memxxxxxx501 ea = type - 3 if tags match ; then sp - mem ( ea ) ← r ( pe - c / s @ rit / pet ) else nop store pe #( pet ) ring #( rit ) c / s in memxxxxxx510 ea = type - 3 ring - 0 / sp - mem - 0 ( ea ) ← r ( trgt @ ring - 0 / pet ) ring - 1 / sp - mem - 1 ( ea ) ← r ( trgt @ ring - 1 / pet ) ring - 2 / sp - mem - 2 ( ea ) ← r ( trgt @ ring - 2 / pet ) ring - 3 / sp - mem - 3 ( ea ) ← r ( trgt @ ring - 3 / pet ) __________________________________________________________________________