Array processor dotted communication network based on H-DOTs
RELATED APPLICATIONS 
     This is a continuation of application Ser. No. 07/887,997, filed on May 22, 1992 now abandoned which is a continuation-in-part application Ser. No. 07/611/594 filed on Nov. 13, 1990 abandoned which is a continuation-in-part application Ser. No. 07/798,788 filed on Nov. 27, 1991 abandoned. 
     The present application claims priority and is a continuation-in-part of the following related patent applications: 
     U.S. patent application Ser. No. 611,594, filed Nov. 13, 1990, of J. Dieffenderfer et al., entitled &#34;Parallel Associative Processor System&#34; now abandoned; and 
     U.S. patent application Ser. No. 798,788, filed Nov. 27, 1991, of P. M. Kogge, entitled &#34;Dynamic Multi-Mode Parallel Processor Array Architecture&#34; now abandoned. 
     In addition, this application is related to the following applications filed concurrently herewith: 
     U.S. patent application Ser. No. 07/887,718, filed May 22, 1992, of P. A. Wilkinson et al., entitled &#34;Instructions within a SIMD Processing Element&#34;: and 
     U.S. patent application Ser. No. 07/887,514, filed May 22, 1992, of P. A. Wilkinson et al., entitled &#34;Floating Point Implementation on a SIMD Machine&#34;; and 
     U.S. patent application Ser. No. 07/887455, filed May 22, 1992, of P. A. Wilkinson et al., entitled &#34;Grouping of SIMD Pickets&#34;; and 
     U.S. patent application Ser. No. 07/887,456, filed May 22, 1992, of P. A. Wilkinson et al., entitled &#34;Slide Network for an Array Processor&#34;; and 
     U.S. patent application Ser. No. 07/887,256, filed May 22, 1992, of P. A. Wilkinson et al., entitled &#34;Picket Autonomy on a SIMD Machine&#34;; and 
     U.S. patent application Ser. No. 07/887,459, filed May 22, 1992, now abandoned in favor of its continuation application Ser. No. 08/292,943, filed Aug. 18, 1994, of P. A. Wilkinson et al., entitled &#34;A SIMD/MIMD parallel processor Array Controller&#34;. 
     Further this application is related to: 
     U.S. patent application Ser. No. 07/887,630, filed May 22, 1992, of T. Barker, et al., entitled &#34;Advanced Parallel Array Processor&#34;, and 
     U.S. patent application Ser. No. 07/888,000, filed May 22, 1992, of T. Barker, et al., entitled &#34;SIMD/MIMD Processing Memory Element&#34;; and 
     U.S. patent application Ser. No. 07/993,255, filed Dec. 18, 1992, of T. Barker, et al., entitled &#34;PME Store and Forward/Circuit Switched Modes&#34;; and 
     U.S. patent application Ser. No. 07/887,508, filed May 22, 1992, of T. Barker, et al., entitled &#34;Fully Distributed Processing Memory Element&#34;; and 
     U.S. patent application Ser. No. 07/887,612, filed May 22, 1992, of M. Dapp, et al., entitled &#34;Advanced Parallel Processor Array Director&#34;; and 
     U.S. patent application Ser. No. 07/887,512, filed May 22, 1992, of M. Dapp, et al., entitled &#34;APAP Mechanical Packaging&#34;; and 
     U.S. patent application Ser. No. 07/887,684, filed May 22, 1992, of T. Barker, et al., entitled &#34;N-Dimensional Modified Hypercube&#34;; and 
     U.S. patent application Ser. No. 07/887,258, filed May 22, 1992, of M. Dapp, et al., entitled &#34;APAP I/O Programmable Router&#34;; and 
     U.S. patent application Ser. No. 07/887,259, filed May 22, 1992, of T. Barker, et al.. entitled &#34;APAP I/O Zipper Connection&#34;; and 
     These co-pending applications and the present application are owned by one and the same assignee, International Business Machines Corporation of Armonk, N.Y. 
     The descriptions set forth in these co-pending applications are incorporated into the present application by reference. 
    
    
     CROSS REFERENCE TO OTHER CO-PENDING PATENT APPLICATIONS 
     Other commonly owned Co-Pending applications also assigned to the same assignee as the present application at the time of filing include: 
     U.S. patent application Ser. No. 07/250,595, filed Sep. 27, 1988, now abandoned in favor of its continuation application Ser. No. 07/519,332, filed May 4, 1990 of James L. Taylor entitled &#34;SIMD Array Processor&#34; (which was originally published as EPO application Ser. No. 88307855/88-A on May 3, 1989); and 
     U.S. patent application Ser. No. 07/193,990, filed May 13, 1988, of H. Li, entitled &#34;Methods and Circuit for Implementing an Arbitrary Graph on a Polymorphic Mesh&#34;; and 
     U.S. patent application Ser. No. 07/426,140, filed Oct. 24, 1989, of R. Jaffe et al entitled &#34;Two-Dimensional Input/Output Scheme for Massively Parallel SIMD Computers&#34;; and 
     U.S. patent application Ser. No. 07/439,758, filed Nov. 21, 1989, of W. C. Dietrich, Jr. et al entitled &#34;Method and Apparatus for Performing Memory Protection Operations in a Parallel Processor System&#34;: and 
     U.S. patent application Ser. No. 07/698,866, filed May 13, 1991, of David B. Rolfe, entitled &#34;Method for Interconnecting and System of Interconnected Processing Elements&#34;. 
     All above referenced co-pending applications are also are owned by one and the same assignee, namely, International Business Machines Corporation of Armonk, N.Y. 
     The descriptions set forth in these co-pending applications are also incorporated by reference. 
     FIELD OF THE INVENTION 
     These inventions relate to computers and computer systems, particularly to arrays of processors and to their communication networks that interconnect SIMD, MIMD, and SIMIMD processing elements and provide the network for passing information throughout the array of processors. 
     GLOSSARY OF TERMS 
     ALU 
     ALU is the arithmetic logic unit portion of a processor. 
     Array 
     Array refers to an arrangement of elements in one or more dimensions. An array can include an ordered set of data items (array element) which in languages like Fortran are identified by a single name. In other languages such a name of an ordered set of data items refers to an ordered collection or set of data elements, all of which have identical attributes. A program array has dimensions specified, generally by a number or dimension attribute. The declarator of the array may also specify the size of each dimension of the array in some languages. In some languages, an array is an arrangement of elements in a table. In a hardware sense, an array is a collection of structures (functional elements) which are generally identical in a massively parallel architecture. Array elements in data parallel computing are elements which can be assigned operations and when parallel can each independently and in parallel execute the operations required. Generally, arrays may be thought of as grids of processing elements. Sections of the array may be assigned sectional data, so that sectional data can be moved around in a regular grid pattern. However, data can be indexed or assigned to an arbitrary location in an array. 
     Array Director 
     An Array Director is a unit programmed as a controller for an array. It performs the function of a master controller for a grouping of functional elements arranged in an array. 
     Array Processor 
     There two principal types of array processors - multiple instruction multiple data (MIMD) and single instruction multiple data (SIMD). In a MIMD array processor, each processing element in the array executes its own unique instruction stream with its own data. In a SIMD array processor, each processing element in the array is restricted to the same instruction via a common instruction stream; however, the data associated with each processing element is unique. Our preferred array processor has other characteristics. We call it Advanced Parallel Array Processor, and use the acronym APAP. 
     Asynchronous 
     Asynchronous is without a regular time relationship; the execution of a function is unpredictable with respect to the execution of other functions which occur without a regular or predictable time relationship to other function executions. In control situations, a controller will address a location to which control is passed when data is waiting for an idle element being addressed. This permits operations to remain in a sequence while they are out of time coincidence with any event. 
     BOPS/GOPS 
     BOPS or GOPS are acronyms having the same meaning--billions of operations per second. See GOPS. 
     Circuit Switched/Store Forward 
     These terms refer to two mechanisms for moving data packets through a network of nodes. Store Forward is a mechanism whereby a data packet is received by each intermediate node, stored into its memory, and then forwarded on towards its destination. Circuit Switch is a mechanism whereby an intermediate node is commanded to logically connect its input port to an output port such that data packets can pass directly through the node towards their destination, without entering the intermediate node&#39;s memory. 
     Cluster 
     A cluster is a station (or functional unit) which consists of a control unit (cluster controller) and the hardware (which may be terminals, functional units, or visual components) attached to it. Our Cluster includes an array of PMEs sometimes called a Node array. Usually a cluster has 512 PMEs. 
     Our Entire PME node array consists of a set of clusters, each cluster supported by a cluster controller (CC). 
     Cluster controller 
     A cluster controller is a device that controls input/output (I/O) operations for more than one device or functional unit connected to it. A cluster controller is usually controlled by a program stored and executed in the unit as it was in the IBM 3601 Finance Communication Controller, but it can be entirely controlled by hardware as it was in the IBM 3272 Control Unit. 
     Cluster synchronizer 
     A cluster synchronizer is a functional unit which manages the operations of all or pad of a cluster to maintain synchronous operation of the elements so that the functional units maintain a particular time relationship with the execution of a program. 
     Controller 
     A controller is a device that directs the transmission of data and instructions over the links of an interconnection network; its operation is controlled by a program executed by a processor to which the controller is connected or by a program executed within the device. 
     CMOS 
     CMOS is an acronym for Complementary Metal-Oxide Semiconductor technology. It is commonly used to manufacture dynamic random access memories (DRAMs). NMOS is another technology used to manufacture DRAMS. We prefer CMOS but the technology used to manufacture the APAP is not intended to limit the scope of the semiconductor technology which is employed. 
     Dotting 
     Dotting refers to the joining of three or more leads by physically connecting them together. Most backpanel busses share this connection approach. The term relates to OR DOTS of times past but is used here to identify multiple data sources that can be combined onto a bus by a very simple protocol. 
     Our I/O zipper concept can be used to implement the concept that the port into a node could be driven by the port out of a node or by data coming from the system bus. Conversely, data being put out of a node would be available to both the input to another node and to the system bus. Note that outputting data to both the system bus and another node is not done simultaneously but in different cycles. 
     Dotting is used in the H-DOT discussions where Two-ported PEs or PMEs or Pickets can be used in arrays of various organizations by taking advantage of dotting. Several topologies are discussed including 2D and 3D Meshes, Base 2 N-cube, Sparse Base 4 N-cube, and Sparse Base 8 N-cube. 
     DRAM 
     DRAM is an acronym for dynamic random access memory, the common storage used by computers for main memory. However, the term DRAM can be applied to use as a cache or as a memory which is not the main memory. 
     FLOATING-POINT 
     A floating-point number is expressed in two pads. There is a fixed point or fraction pad, and an exponent pad to some assumed radix or Base. The exponent indicates the actual placement of the decimal point. In the typical floating-point representation a real number 0.0001234 is represented as 0.1234-3, where 0.1234 is the fixed-point pad and -3 is the exponent. In this example, the floating-point radix or base is 10, where 10 represents the implicit fixed positive integer base, greater than unity, that is raised to the power explicitly denoted by the exponent in the floating-point representation or represented by the characteristic in the floating-point representation and then multiplied by the fixed-point pad to determine the real number represented. Numeric literals can be expressed in floating-point notation as well as real numbers. 
     FLOPS 
     This terms refers to floating-point instructions per second. Floating-point operations include ADD, SUB, MPY, DIV and often many others. Floating-point instructions per second parameter is often calculated using the add or multiply instructions and, in general, may be considered to have a 50/50 mix. An operation includes the generation of exponent, fraction and any required fraction normalization. We could address 32 or 48-bit floating-point formats (or longer but we have not counted them in the mix.) A floating-point operation when implemented with fixed point instructions (normal or RISC) requires multiple instructions. Some use a 10 to 1 ratio in figuring performance while some specific studies have shown a ratio of 6.25 more appropriate to use. Various architectures will have different ratios. 
     Functional unit 
     A functional unit is an entity of hardware, software, or both, capable of accomplishing a purpose. 
     Gbytes 
     Gbytes refers to a billion bytes. Gbytes/s would be a billion bytes per second. 
     GIGAFLOPS 
     (10)**9 floating-point instructions per second. 
     GOPS and PETAOPS 
     GOPS or BOPS, have the same meaning--billions of operations per second. PETAOPS means trillions of operations per second, a potential of the current machine. For our APAP machine they are just about the same as BIPs/GIPs meaning billions of instructions per second. In some machines an instruction can cause two or more operations (i.e. both an add and multiply) but we don&#39;t do that. Alternatively it could take many instructions to do an op. For example we use multiple instructions to perform 64 bit arithmetic. In counting ops however, we did not elect to count log ops. GOPS may be the preferred use to describe performance, but there is no consistency in usage that has been noted. One sees MIPs/MOPs then BIPs/BOPs and Mega FLO PS/Giga FLO PS/Tera FLOPS/PetaFlops. 
     ISA 
     ISA means the Instruction Set Architecture. 
     Link 
     A link is an element which may be physical or logical. A physical link is the physical connection for joining elements or units, while in computer programming a link is an instruction or address that passes control and parameters between separate portions of the program. In multisystems a link is the connection between two systems which may be specified by program code identifying the link which may be identified by a real or virtual address. Thus generally a link includes the physical medium, any protocol, and associated devices and programming; it is both logical and physical. 
     MFLOPS 
     MFLOPS means (10)**6 floating-point instructions per second. 
     MIMD 
     MIMD is used to refer to a processor array architecture wherein each processor in the array has its own instruction stream, thus Multiple Instruction stream, to execute Multiple Data streams located one per processing element. 
     Module 
     A module is a program unit that is discrete and identifiable or a functional unit of hardware designed for use with other components. Also, a collection of PEs contained in a single electronic chip is called a module. 
     Node 
     Generally, a node is the junction of links. In a generic array of PEs, one PE can be a node. A node can also contain a collection of PEs called a module. In accordance with our invention a node is formed of an array of PMEs, and we refer to the set of PMEs as a node. Preferably a node is 8 PMEs. 
     Node array 
     A collection of modules made up of PMEs is sometimes referred to as a node array, is an array of nodes made up of modules. A node array is usually more than a few PMEs, but the term encompasses a plurality. 
     PDE 
     A PDE is a partial differential equation. 
     PDE relaxation solution process 
     PDE relaxation solution process is a way to solve a PDE (partial differential equation). Solving PDEs uses most of the super computing compute power in the known universe and can therefore be a good example of the relaxation process. There are many ways to solve the PDE equation and more than one of the numerical methods includes the relaxation process. For example, if a PDE is solved by finite element methods relaxation consumes the bulk of the computing time. Consider an example from the world of heat transfer. Given hot gas inside a chimney and a cold wind outside, how will the temperature gradient within the chimney bricks develop? By considering the bricks as tiny segments and writing an equation that says how heat flows between segments as a function of temperature differences then the heat transfer PDE has been converted into a finite element problem. If we then say all elements except those on the inside and outside are at room temperature while the boundary segments are at the hot gas and cold wind temperature, we have set up the problem to begin relaxation. The computer program then models time by updating the temperature variable in each segment based upon the amount of heat that flows into or out of the segment. It takes many cycles of processing all the segments in the model before the set of temperature variables across the chimney relaxes to represent actual temperature distribution that would occur in the physical chimney. If the objective was to model gas cooling in the chimney then the elements would have to extend to gas equations, and the boundary conditions on the inside would be linked to another finite element model, and the process continues. Note that the heat flow is dependent upon the temperature difference between the segment and its neighbors. It thus uses the inter-PE communication paths to distribute the temperature variables. It is this near neighbor communication pattern or characteristic that makes PDE relation very applicable to parallel computing. 
     PICKET 
     This is the element in an array of elements making up an array processor. It consists of: data flow (ALU REGS), memory, control, and the portion of the communication matrix associated with the element. The unit refers to a 1/nth of an array processor made up of parallel processor and memory elements with their control and portion of the array intercommunication mechanism. A picket is a form of processor memory element or PME. Our PME chip design processor logic can implement the picket logic described in related applications or have the logic for the array of processors formed as a node. The term PICKET is similar to the commonly used array term PE for processing element, and is an element of the processing array preferably comprised of a combined processing element and local memory for processing bit parallel bytes of information in a clock cycle. The preferred embodiment consisting of a byte wide data flow processor, 32k bytes or more of memory, primitive controls and ties to communications with other pickets. 
     The term &#34;picket&#34; comes from Tom Sawyer and his white fence, although it will also be understood functionally that a military picket line analogy fits quite well. 
     Picket Chip 
     A picket chip contains a plurality of pickets on a single silicon chip. 
     Picket Processor system (or Subsystem) 
     A picket processor is a total system consisting of an array of pickets, a communication network, an I/O system, and a SIMD controller consisting of a microprocessor, a canned routine processor, and a micro-controller that runs the array. 
     Picket Architecture 
     The Picket Architecture is the preferred embodiment for the SIMD architecture with features that accommodate several diverse kinds of problems including: 
     set associative processing 
     parallel numerically intensive processing 
     physical array processing similar to images 
     Picket Array 
     A picket array is a collection of pickets arranged in a geometric order, a regular array. 
     PME or processor memory element 
     PME is used for a processor memory element. We use the term PME to refer to a single processor, memory and I/O capable system element or unit that forms one of our parallel array processors. A processor memory element is a term which encompasses a picket. A processor memory element is 1/nth of a processor array which comprises a processor, its associated memory, control interface, and a portion of an array communication network mechanism. This element can have a processor memory element with a connectivity of a regular array, as in a picket processor, or as pad of a subarray, as in the multi-processor memory element node we have described. 
     Routing 
     Routing is the assignment of a physical path by which a message will reach its destination. Routing assignments have a source or origin and a destination. These elements or addresses have a temporary relationship or affinity. Often, message routing is based upon a key which is obtained by reference to a table of assignments. In a network, a destination is any station or network addressable unit addressed as the destination of information transmitted by a path control address that identifies the link. The destination field identifies the destination with a message header destination code. 
     SIMD 
     A processor array architecture wherein all processors in the array are commanded from a Single Instruction stream to execute Multiple Data streams located one per processing element. 
     SIMDMIMD or SIMD/MIMD 
     SIMDMIMD or SIMD/MIMD is a term referring to a machine that has a dual function that can switch from MIMD to SIMD for a period of time to handle some complex instruction, and thus has two modes. The Thinking Machines, Inc. Connection Machine model CM-2 when placed as a front end or back end of a MIMD machine permitted programmers to operate different modes for execution of different pads of a problem, referred to sometimes a dual modes. These machines have existed since Illiac and have employed a bus that interconnects the master CPU with other processors. The master control processor would have the capability of interrupting the processing of other CPUs. The other CPUs could run independent program code. During an interruption, some provision must be made for checkpointing (closing and saving current status of the controlled processors). 
     SIMIMD 
     SIMIMD is a processor array architecture wherein all processors in the array are commanded from a Single Instruction stream, to execute Multiple Data streams located one per processing element. Within this construct, data dependent operations within each picket that mimic instruction execution are controlled by the SIMD instruction stream. 
     This is a Single Instruction Stream machine with the ability to sequence Multiple Instruction streams (one per Picket) using the SIMD instruction stream and operate on Multiple Data Streams (one per Picket). SIMIMD can be executed by a processor memory element system. 
     SISD 
     SISD is an acronym for Single Instruction Single Data. 
     Swapping 
     Swapping interchanges the data content of a storage area with that of another area of storage. 
     Synchronous Operation 
     Synchronous operation in a MIMD machine is a mode of operation in which each action is related to an event (usually a clock); it can be a specified event that occurs regularly in a program sequence. An operation is dispatched to a number of PEs who then go off to independently perform the function. Control is not returned to the controller until the operation is completed. 
     If the request is to an array of functional units, the request is generated by a controller to elements in the array which must complete their operation before control is returned to the controller. 
     TERAFLOPS 
     TERAFLOPS means (10)**12 floating-point instructions per second. 
     VLSI 
     VLSI is an acronym for very large scale integration (as applied to integrated circuits). 
     Zipper 
     A zipper is a new function provided. It allows for links to be made from devices which are external to the normal interconnection of an array configuration. 
     BACKGROUND OF THE INVENTION 
     In the never ending quest for faster computers, engineers are linking hundreds, and even thousands of low cost microprocessors together in parallel to create super supercomputers that divide in order to conquer complex problems that stump today&#39;s machines. Such machines are called massively parallel. We have created a new way to create massively parallel systems. The many improvements which we have made should be considered against the background of many works of others. A summary of the field has been made in other applications which are referenced. See in this connection the related application for our Parallel Associative Processor System, U.S. Ser. No. 601,594 and our Advanced Parallel Array Processor (APAP). System tradeoffs are required to pick the architecture which best suits a particular application but no single solution has been satisfactory. Our ideas make it easier to provide a solution. 
     The interrelationship of the processors in an array of processors and the methods used to communicate among the processors has been the focus of considerable study as documented in the literature related to such arrays. Studies have focused on minimizing the number of steps to move a message between any two elements of the array, Studies have focused on nearby communication to support image processing and other such very regular problems. In short, A parallel processor array of the SIMD or MIMD type requires a highly organized and efficient connection network for communication among processing elements (PEs). 
     A communication network can be required to communicate synchronously where all pickets transfer data in the same direction at the same time, or it can be required to communicate randomly as where each picket sends out a message at random times to random places. This later approach we call a routed transfer. 
     Synchronous transfers and router transfers may need to be addressed on either a MIMD or a SIMD array control architecture while attempting to keep the communication complexity simple. 
     Several communication topologies are described in the literature and implemented in various ways is array machines. A basic communication topology is the simple left-right connectivity of a linear array. In a linear array each of the two port PEs communicate with the PE on either the left of the right via a point to point network. In a more extensive conventional mesh topology of two or more dimensions, the communication network is implemented by using direct links between a source element and the elements in each of the implemented dimensions. Thus, each element has two links for each dimension of the array as where in a conventional two dimensional array with NEWS (north, east, west, south) network, each element will have four links to other elements, and if another dimension is added, two more links must be added to each element of the mesh. Within each element of a conventional mesh there may be a router function that receives and transmits messages or data packets over the appropriate links. The Hypercube in several of it&#39;s multibased multidimensional embodiments represents something near the ultimate in processor array communication networks. With the binary hypercube, for example, the number of ports quickly grows to significant proportions. 
     The processing element (PE) in a conventional array requires enough ports to reach the necessary elements with point to point network links. Some PEs need four ports, some 6, some 8, and some 30 (15 dimensional binary hypercube with 32k elements), depending on topology and extent of the implemented network. Also, each link can contain from one up to possibly 50 parallel lines to accommodate the ever increasing data transfer rate demands. 
     Now, as we are putting these topologies into hardware, the packaging of these arrays into chips, cards, drawers, racks, and rooms causes us to quickly focus on the number of links and the number of signal pins in each link. As wafer technology allows more circuits per chip, arrays of parallel processors are becoming more affordable, and more dense arrays are desired. 
     This application focuses on using DOTable networks to interconnect two port PEs to realize many of the topologies of today while significantly reducing packaging pincounts. The packaging of an array of pickets with any mesh configuration poses several packaging problems, most of which relate to limited available package pins, or the desire to minimize the number of pins required. 
     In the patent art there are some patents which generally talk about SIMD and other networks. Among them are U.S. Pat. No. 4,270,170 of Reddaway, entitled &#34;Array Processor&#34;, which discusses a NEWS network connected SIMD array wherein a dotted three branch network is used to interconnect chips containing 4 PE each. Simultaneous transfer in one of the directions is accommodated. By using the dotted networks, the ports on one chip are reduced from 8 to 6 thereby achieving a 25% reduction in pin count. Only a 2D network is mentioned. A global routing scheme is directed by two lines which reach all elements in the array and encode the 4 directions common to a NEWS network. While this patent is representative of a prior dotted network to reduce pin and port count through out the network, it can not address four branches on each network but only three, and it provides more than three ports per processing element (3.5 on the average), leading to higher pin and port counts than we have found could be achieved. This patent only addresses a 2D NEWS network. We show it is desirable to accommodate extension into other dimensions and configurations and these problems are not addressed by this patent. Apparently, the array of this patent requires simultaneous transfer of data in a specified direction. 
     U.S. Pat. No. 4,468,727 of Carrison, entitled &#34;Integrated Cellular Array Parallel Processor&#34;, discusses an array processor that is integrated with an array of radiation sensors such that image processing is performed on the same monolithic substrate with the sensors. Interconnection between the processing elements is accomplished with charge coupled gates on the NEWS edges of each PE, and as such represents just one of many NEWS arrays. It has no dotted communication network. 
     U.S. Pat. No. 4,805,091 of Thiel, entitled &#34;Method and Apparatus for Interconnecting Processors in a Hyper-Dimensional Array&#34;, on the other hand, is a good example of the hypercube interconnection network employed by the machines made by Thinking Machines, Inc., e.g. a &#34;Connection Machine&#34;, and it discusses the application of the binary hypercube to the packaging of PEs with chips, cards, boards, and frames where each level of package is accomplished with a higher (or lower) dimension of the hypercube. While this U.S. Pat. No. 4,805,091 patent does not mention any form of DOTing mechanism, it describes the binary hypercube. This is another example of the applicability of our invention of a dotted communication network for array processors, as our invention can be applied to implement a binary hypercube. The patent however, makes no mention of dotted buses as we will illustrate. 
     U.S. Pat. No. 4,985,832 of Grondalski, entitled &#34;SIMD Array Processing System with Routing Networks Having a Plurality of Switching Stages to Transfer Messages Among Processors&#34;, is another example of SIMD Array Processing Systems having routing networks. They address small groups of PEs that communicate via memory sharing; a NEWS mesh providing for regular array processing; a mechanism whereby PEs can share a large broadcast communication task; and a random routing network comprised of some &#34;butterfly&#34; stages followed by a 16×16 crossbar switch; but this patent focuses on random routing including a crossbar switch chip and its fault tolerant aspects. While this patent focuses on a number of communication schemes, it does not describe any dotted mechanism. 
     U.S. Pat. No. 4,910,665 of Mattheyses, entitled &#34;Distributed Processing System Including Reconfigurable Elements&#34;, discusses a two dimensional SIMD array processor interconnection scheme whereby each PE has direct access to 8 of its neighbors. The communication media is a dotted network that interconnects four neighbors at the corners. Each PE enjoys four such dotted networks each. The suggestion of the X-DOT of this U.S. Pat. No. 4,910,665 patent and the dotted connection that we call an H-DOT both permit four PEs to be joined together by a dotted network. However, U.S. Pat. No. 4,910,665 discusses only the mesh topology and extensions into toroids, and focuses on the circuit within a PE. We believe there needs to be improvements in the focus on the connectivity, and routing. 
     SUMMARY OF THE INVENTIONS 
     The improvements which we have made achieve a dotted network structure (H-DOT). H-DOT reduces the magnitude of the networking implementation. Our preferred embodiment applies to several topologies. Furthermore, with H-DOT connecting processing elements in a array, the array of processors can generally be extended in size and in additional dimensions while retaining a basic two port array processing element. Both synchronous and routed transfer control can be included, and we will discuss our routing algorithms. 
     As new machines with parallel arrays and multi-byte word transfers can now be obtained on a chip, pin count becomes a serious problem as mesh communication paths become more parallel. The present invention can be used to connect microcomputers with parallel communication paths. 
     Our H-DOT concept fits in here quite well, because it enables parallel communication with various topologies. The H-DOT concept is an approach for applying a processing element with two ports (or more in some cases) to a variety of interconnection topologies. Pin count can be significantly reduced, while the basic elements retain only two port devices. A result of our approach is the ability to extend a mesh to additional dimensions with the same two port element concept. In our preferred embodiment, we limit each PE to exactly two ports regardless of the desired configuration. So each PE (or picket) attaches to exactly two nets. 
     We provide that each net may extend to several other pickets, and in multiple dimensions. 
     Pin count is reduced, and our routing algorithm which is mechanized takes advantage of the above features. The routing algorithm that handles a message after it has been received is brutally simple. Either keep the message if it is mine, or pass it out the other port if it is not. 
     Among the advantages of the H-DOT approach are: 
     reduced pins; 
     simplified router algorithms; 
     lower transient time through a network; 
     potentially fewer hops; 
     higher signal utilization in a lightly loaded system; 
     ability to be configured into standard nets; and 
     significant fault tolerance capability with alternate routings. 
     We have created a new way to make massively parallel processors and other computer systems by creating a new &#34;chip&#34; and systems designed with our new concepts. This application is directed to such systems. Our here and in the related applications may be viewed of our expression of the various concepts we teach in this application, and in the related applications. Components described in each application can be combined in our systems to make new systems. They also can be combined with existing technology. 
     We will elaborate in this and related applications Picket Processors and what we call an Advanced Parallel Array Processor (APAP). It may be interesting to note that the picket processor can employ a PME. A picket processor may be especially useful in military application where a very compact array processor is desirable. In this connection, a picket processor differs somewhat from the preferred embodiment associated with the APAP, our Advanced Parallel Array Processor. However, the commonality exists, and aspects and features which we have provided can be employed in differing machines. 
     The term picket refers to 1/nth element of an array processor made up of processor and memory and their included communication elements applicable for array intercommunication. 
     The picket concept is also applicable to the 1/nth of an APAP processing array. 
     While the picket concept can differ from an APAP in data width, memory size, and number of registers, it is, in the massively parallel embodiment which is an alternative to an APAP, different in that it is configured to have connectivity for 1/nth of a regular array, while a PME in an APAP is a part of a sub-array. Both systems can execute SIMIMD. However, because a picket processor is configured as a SIMD machine with MIMD in the PE, it can directly execute SIMIMD, while a MIMD APAP configuration would execute SIMIMD by using MIMD PEs controlled to emulate SIMD. Both machines use a PME. 
     Both systems can be configured as a parallel array processor, comprising an array processing unit for the array having `N` elements interconnected with an array communication network wherein 1/Nth of the processor array is a processing element, it&#39;s associated memory, a control bus interface, and a portion of the array communication network. 
     The parallel array processor has a dual operation mode capability wherein the processing unit can be commanded to operate in either or two modes, and freely move between these two modes for SIMD and MIMD operation, where when SIMD is the mode of its organization a processing unit has the ability to command each element to execute it&#39;s own instructions in a SIMIMD mode, and where when MIMD is the implementation mode for the processing units organization it has the ability to synchronize selected elements of the array to simulate MIMD execution. We can call this MIMD-SIMD). 
     A parallel array processor in both systems provides an array communication network with paths for the passing of information between elements of the array. The movement of information can be direction by either of two ways, where as a first way, an array controller directs that all messages move in the same direction at the same time such that the data being moved does not define its destination, and in a second way, each message is self routed with a header at the beginning of a message defining its destination. A segment of the parallel array processor array has plural copies of the processing unit provided on a single semiconductor chip, which each copy segment of the array including a portion of the array communication network associated with that segment and buffers, drivers, multiplexers, and control for enabling the segment portion of the array to be seamlessly connected with other segments of the array to extend the array communication network. 
     The control bus or path from a controller is provided for each processing unit so that the control bus extends to each of the elements of the array and controls its activities. 
     Each processing element segment of the parallel array, contains plural copies of a processor memory element, which is contained within the limits of a single semiconductor chip, has a segment of the array includes a portion of the array control bus and the register buffers to support the communication of controls to the array segment contained within the chip. 
     Both can implement mesh moves or routed moves. Normally, the APAP implements a dual interconnect structure, with eight elements on the chip interrelating in one way, while the chips interrelate in another way. The programmable routing on the chip generally causes links to be established between the PMEs as we have described, but the nodes can be and normally are related in another way. On the chip essentially the normal APAP configuration would be a 2×4 mesh, which the node interconnection can be a routed sparse octal N-cube. Both systems have inter-PE intercommunication pathways between PEs (PMEs) enabling a matrix to be made up of point-to-point paths. 
     With this background and perspective, we will describe in detail features and aspects of our invention related to the preferred embodiment of our invention with reference to the FIGURES. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 shows a conventional linear array that makes natural use of two port processing elements (PEs). 
     FIG. 2 shows a conventionally connected NEWS network with a point-to-point link to each of four neighboring PEs. 
     FIG. 3 shows implementation of the NEWS network using H-DOT connection techniques. Note that the PEs are now 2 port instead of 4 port. 
     FIG. 4 shows implementation of a 3 dimensional mesh using H-DOT connection techniques. Note that the PEs are now 2 port instead of the conventional 6 port PEs used in conventional 3D mesh arrays. 
     FIG. 5 shows a conventional binary N-Cube of 4 dimensions implemented with 4 port PEs. 
     FIG. 6 shows implementation of a 4 dimensional binary n-cube using H-DOT connection techniques. Note that the PEs are now 2 port instead of the 4 port PEs shown in FIG. 5. 
     FIGS. 7A-7B show implementation of a 6 dimensional binary n-cube using H-DOT connection techniques. Note that the PEs are now 2 port instead of the 6 port PEs used in a conventional n-cube implementation. 
     FIG. 8 shows a conventional base4 n-cube. There is a path to all PEs that have one base4 address digit that is different from the first PE. 
     FIG. 9 shows a sparse base4 n-cube. There is a path only to the PEs that have one base4 address digit that is different by one address from the first PE. 
     FIG. 10 shows the sparse base4 n-cube that has been implemented with H-DOT connections. The PEa each have 2 ports. 
     FIG. 11 carries the sparse n-cube idea to base 8 and shows such a topology. 
     FIG. 12 shows the sparse octal n-cube implemented using H-DOT connections. Again, the PEa have 2 ports. 
     FIG. 13 shows a block diagram of a parallel array processor we have described with a 2-D H-dot array, while FIG. 14 shows the picket PME we have described. 
    
    
     DETAILED DISCUSSION OF H-DOT 
     Our detailed description explains the preferred embodiments of our invention, together with advantages and features, with reference to the above drawings. 
     A basic communication topology that can be used to pass data from PE to PE is the simple left-right connectivity of a linear array as pictured in FIG. 1 representing a conventional prior art linear array. Each of the two port PEs 10-22 communicates with the PE on either the left or the right via one of the point-to-point networks 11-21. This basic idea of a two port PE is fundamental to the discussion of our H-DOT structure. 
     In the more extensive conventional mesh topology, the communication network is implemented using direct links between a source element and a destination element. Thus, each element has two links for each dimension of the array. For example, in a conventional two dimensional array with NEWS (north, east, west, south) communication, each element will have four links to other elements as shown in FIG. 2. If another dimension is added, two more links must be added to each element of the mesh. Within each element of a conventional mesh is a router function that receives and transmits messages or data packets over the appropriate links. 
     The communication network can be required to communicate synchronously where all pickets transfer data in the same direction at the same time, or it can be required to communicate randomly where each picket sends out a message at random times to random places. This later approach we call a routed transfer. Both of these kinds of communication may need to be addressed on either a MIMD or a SIMD array control architecture while attempting to keep the communication complexity simple. 
     Each link can contain from 1 up to possibly 50 parallel lines to accommodate the ever increasing data transfer rate demands. 
     The packaging of an array of pickets with any mesh configuration poses several packaging problems, most of which relate to limited available package pins, or to a desire to minimize the number of pins required. 
     The Parallel Associative Processor System, referenced above as a related application, has been described in the parent application with emphasis on a linear left/right communication mesh. There are, however, several interconnection meshes to consider. Some of these are: 
     
         ______________________________________                                    
L/R Mesh            NEWS Mesh                                             
Slide Bus           Shuffle Network                                       
Simple Crossbar     Base 2 N-cube                                         
Slide Crossbar      Base 8 N-cube                                         
______________________________________                                    
 
    
     We will discuss how to implement several of these array interconnection topologies using the H-dot idea to significantly reduce port and pin count in a given topology. 
     APPROACH--H-DOT 
     Control of mesh communications can be classified in two categories. If the communication is regular, some form of global control will tell all the pickets to do the same thing. This can be simultaneous or phased in some way. This type of communication is generally associated with SIMD control organizations; however, it works equally well with a MIMD organized array. 
     Our preferred embodiment, H-DOT, can implement one of several mesh configurations all based on the same basic two port element. H-DOT takes two or more point-to-point links and combines their function into one network with attachments to more than two PEs. In implementing a 2D mesh using H-DOT interconnects (FIG. 3), for example, two adjacent N-S links (e.g., link H-to-A and link G-to-B) and two adjacent E-W links (e.g., link H-to-G and link A-to-B) are joined into one network 50 with attachments to 4 PEs (i.e., PEs H, G, B and A). If one is counting, this 4 port network 50 of the H-DOT interconnected 2D mesh of FIG. 3 replaces 4 two-port links 30-34 required by the prior art 2D mesh of FIG. 2, and thereby reduces the pin count by 50%. Also, it can be seen, because the N-S links (i.e., link H-to-A and link G-to-B) share the same wire of network 50, an array wide synchronous transfer will require 2 cycles. One of the cycles can be for the even PEs and the other cycle can be for the odd PEs. With H-DOT the interconnection of processing elements is dot-OR as illustrated in FIG. 3, such that a PE can interconnect to a next PE by a link that provides two vertical paths and two horizontal paths to the link, an apparent H connection link. A square processing element in our preferred embodiment is more than one processing element, and alternatively is a picket or a chip with eight or sixteen pickets. In this connection, reference should be made to the related application for additional details of our preferred processing element. However, as to this application, our square can represent a conventional microcomputer. 
     While we have above summarized advantages of the H-DOT approach, as with most things, there are drawbacks. Listed here are some effects of the H-DOT concept which in some environments will have a minor impact, but in other applications these effects could be significant. These effects are: 
     1. In synchronous transfers, where all elements pass data in the same direction at the same time, the H-DOT implementations require 2 clocks (or cycles) where conventional implementation requires one. 
     2. When routed transfers are being implemented, the H-DOT approach will introduce temporary blocking that could be important when communication traffic is heavy. The result is longer transfer time, not missed messages altogether. 
     If communication is of the random type, each message carries a destination address, and passes through the network with possible stops at intermediate nodes. Thus, each element must implement some form of routing algorithm. The router can be independent of the parallel processor control organization, or can be integrated with it. 
     With a two port element, not much of an algorithm is needed to decide what to do with a message that has been received by the element. The message either belongs to the element or is transferred out the other side. This algorithm is universal for all forms of mesh implemented with two port pickets or PEs. 
     There is another algorithm that determines whether to accept a message that is available at a port. In a two dimensional NEWS network, there are four ports that have access to a message, but only one can actually receive the message. The algorithm to decide to receive a message is based on getting the message to its destination while avoiding non-functional paths. The accept algorithm is based on the configuration of the array and will be discussed with the specific arrays. 
     Now we will detail more about H-DOT for the following mesh topologies. 
     North South East West (NEWS) mesh; 
     3 D mesh: 
     binary N-Cube: 
     Base 4 N-Cube; and 
     Octal N-Cube. 
     THREE-D NEWS ARRAY 
     This first description uses the basic 2 port picket that is used in the previously discussed East West slide bus shown in FIG. 1 to achieve a 2 dimensional NEWS array. 
     H-DOT, in concept, uses a wire dot-OR to connect a port from 4 (or more). different pickets. Another dot-OR connects the other port of one of the pickets to three (or more) other pickets. FIG. 3 shows the basic H-DOT pattern for a 2 dimensional mesh. 
     One of the advantages of the H-DOT approach is that the number of pins on each element is reduced by 1/2, and the number of links in various parts a 2D mesh are reduced by more than 1/2 as compared to what is needed with a conventional 2D (four port) mesh. A quick look at FIG. 3 shows that a single H-DOT link is providing two vertical paths and two horizontal paths. 
     Another advantage of the H-DOT approach is extensibility. We can go from the 2-D mesh just shown to a three dimensional mesh by implementing a double H-DOT as shown in FIG. 4. Here, four elements of the 3-D array are connected with a DOT network that looks like a Double-H with one H on top of the other. The inset of FIG. 4 shows one double H-DOT for clarity. In the bigger FIG. 4, these double H-DOTs are staggered in each dimension so that each PE has connection to each neighbor in each direction, and to maintain the double H-DOT connection integrity. 
     Communication over the H-DOT takes more communication cycles than with point-to-point links. The 2D H-DOT takes one or two cycles for each picket to send data to the picket on a specified side. Also, the double H forms 4 paths in each dimension, and thus, takes four cycles for all pickets to send data to the picket in a specified direction. 
     ROUTING ALGORITHM 
     The NEWS network is designed to be used for image and other regularly arranged data processing. In this case, the array controller tells all elements to simultaneously pass data to the elements on the same side. 
     A NEWS network can also be used for random communication. In this case, each element must have a router with a routing algorithm for initiating, receiving, and passing on messages. With the H-DOT approach, an element must decide to accept a message from an active port. Referring to FIG. 3, if element A sees a message from the left port, it accepts it if the destination address is: 
     its own address (Xd=Xo, Yd=Yo) 
     -OR- 
     in the upper right quadrant of the mesh 
     i.e.. the destination X address is=&gt;than own address 
     or, the destination Y address is=&lt;that own address 
     Notice that there are 4 different algorithms depending on whether an element is in position A, B, C, or D. 
     BINARY HYPERCUBE 
     The next topology for discussion uses H-DOT to implement the binary hypercube. 
     FIG. 5, shows a typical binary hypercube of 4 dimensions. Each element of the cube has one connection for each dimension. Because each dimension only has two values, an array of significant size has a lot of dimensions. A 4 d cube has 16 elements with 4 ports each. An array with 1024 elements is a 10 d binary cube with 10 ports on each element. 
     When the binary n-cube is implemented in H-DOT, a 4 dimension version would look like FIG. 6. Each element has two ports and is connected with dot-OR buses, in the characteristic H-DOT configuration (a little bent), to its communication partners. 
     The H-DOT, while limiting the number of ports per element to two and significantly reducing the pin count over conventional implementations, has increased the number of destination options that a message can reach in one move. For example, in a conventional n-cube, element 0000 can communicate on four links to these addressable processing elements: 0001, 0010, 0100, and 1000 in one move. With the H-DOT implementation, element 0000 can communicate on two links to elements: 0001, 0100, 0101, 0010, 1000, and 1010 in one move. On a 4 dimensional binary cube implemented in H-DOT, the average number of moves per message could be reduced by 25% over a conventional binary cube with low message densities if these additional connections were used. In a way, this H-DOT implementation of the binary n-cube results in something that is no longer just a binary n-cube. The definition of a binary n-cube states that a PE has connection to other PEs whose address differs by 1 bit from this PE. In any case, it is more and not less than a binary n-cube. 
     In FIG. 7 we are looking at the 6 dimensional binary cube implemented in H-DOT with two-port PEs. Also, one may notice that the maximum moves for sending a message from any one of the 64 elements to any other is two moves. And, each double H-DOT connects to eight PEs. 
     At some point, the H-DOT becomes ineffective because of the problems of large wire-dot nets, and the potential for collisions on them in high message densities. This may limit the application of H-DOT in binary n-cubes to relatively small arrays where the number- of PEs per H-DOT is 32 or so. Sinking current in large dot-OR networks becomes an issue. This statement applies specifically to binary cubes; however, interposing a transceiver in the net at some point removes some of these issues. The NEWS network does not have this problem because it remains a 2 dimensional array no matter how extensive it is, although random communication must traverse more intermediate nodes. 
     ROUTING ALGORITHM FOR BINARY N-CUBE 
     Notice in FIG. 6 and FIG. 7 that each element and each H-DOT is identified. The upper left element is numbered 0000, and one of its links is numbered x0x0. The link name is the reference to all the elements attached to it. The accept algorithm for a routed transfer mechanization is based on these link names. 
     When an element finds a message that is active on one of its links, one and only one of the elements must accept it. Our algorithm is incredibly simple, &#34;Accept the message when the destination matches the back side link name.&#34; Four destinations match link x0x0. They are 0000, 1000, 0010, and 1010. Notice that the front and back side links are orthogonal to each other, and a destination matches only one link. 
     After an element of the array has chosen to accept a message, it keeps it if the destination address matches its address, &#34;else&#34; it passes it on. 
     When an element of the array needs to originate a message, the destination address will match only one of the two attached H-DOT net names. That is the port on which to start the message. 
     The following is a summary of the implementation of H-DOT on binary n-cubes: 
     
         ______________________________________                                    
                  Simul. Cycles                                           
Dim  Elements Links   Taps/Link                                           
                              Best Worst                                  
______________________________________                                    
1    2        1       2                                                   
2    4        4       2                                                   
3    8        6       4                                                   
4    16       8       4        4   8                                      
5    32       12      8                                                   
6    64       16      8                                                   
7    128      24      16                                                  
8    256      32      16                                                  
9    512      48      32                                                  
10   1024     64      32      32   64 (if all first                       
                                   moves are in 1 axis)                   
______________________________________                                    
 
    
     By way of explanation, the column called &#34;DIM&#34; is the dimension of the binary n-cube. &#34;Elements&#34; is the number of PEs or elements that make up a binary n-cube of this dimension. &#34;Links&#34; is the total number of separate nets or groups of interconnected ports needed to implement the binary n-cube of dimension shown when using the H-DOT interconnection scheme. &#34;Taps/link&#34; is the number of taps or ports in each link. Finally, the last two columns show the minimum and maximum number of cycles needed to simultaneously move data from all elements to the elements in one specific direction. The term &#34;Link&#34; refers to one of the DOTTed networks that tie PEs together. 
     Base4 N-cube 
     There is growing interest in implementations of higher order N-cubes. Interconnection economies are driving this interest. Our H-DOT concept meshes exactly with higher order N-cubes. For simplicity, we explain the Base 4 n-cube from full implementation, through sparse implementation and finally to a sparse Base 4 n-cube implemented using H-DOT. 
     FIG. 8 shows the standard base4 n-cube. Each PE has a connection to another PE if its address matches the other PE&#34;s address in all but one digit. 2 dimensional base4 n-cube has the following 16 elements: 00, 01, 02, 03, 10, 11, 12, 13, 20, 21, 22, 23, 30, 31, 32, and 33. In a base4 n-cube, element 00 will connect directly with 01, 02, 03, 10, 20, and 30. This rule applies to the other PEs as well. Thus, each PE has 6 ports. 
     Sparse Base4 N cube 
     We introduce the idea of sparseness to the 2 dimensional base4 n-cube. To reduce the number of links and to make an array easier to implement, some designers have proposed to simply take out some of the links. This is done by restricting the connections to PEs with all but one digit matching to the two adjacent PEs in that dimension. In the above example, PE 00 then has connections restricted to 01, 03, and 10, and 13. FIG. 9 shows this. 
     H-DOT Implemented Base4 N-cube 
     We implement the sparse 2 dimensional base4 n-cube in an H-DOT mechanization using 2 port PEs. The result is shown in FIG. 10. This is quite a simplification in ports and networks over the implementation of FIG. 8. Remember, of course, that paths are being shared, and more cycles are required. This array can easily be extended to more dimensions as was shown with the Base2 N-cube. 
     H-Dot Octal N-cube 
     A close relative of the binary and base4 N-cube is the octal n-cube which has eight instead of two or four elements in each strip of the array. FIG. 11 shows a conventionally connected sparse 2D octal n-cube. The element of a 2D octal array has a pair of connections for each dimension, one for plus and one for minus. Another pair is added for each additional dimension, as in the binary cube. 
     FIG. 12 shows the H-DOT equivalent of the sparse 2D octal n-cube. All of the prior advantages apply including reduced pin count, enhanced connectivity, and extensibility. 
     The following is a summary of the implementation of H-DOT to octal n-cubes: 
     
         ______________________________________                                    
                        Simul. Cycles                                     
Dim   Elements  Taps/wireDot wireDots                                     
                                    Best Worst                            
______________________________________                                    
1     8         2            8      4                                     
2     64        4            32     4                                     
3     512       8            128    4                                     
4     4096      16           512                                          
5     32768     32           2048                                         
______________________________________                                    
 
    
     The H-DOT interconnect topology is even better applied to n-cubes with higher bases. With an octal (8) base, we can get to a respectable 4096 element array in four dimensions. Distance, even with path conflicts, remains small. The best case distance between any two elements of two dimensional octal n-cube is 8 for conventional topology and 4 for the H-DOT topology. This is a factor of 2 improvement. 
     H-Dot Octal N-cube Routing Algorithm 
     The N-Cube topology generally uses routed message transfer techniques as opposed to synchronous techniques. We have explained n-cubes of different bases, and have introduced sparseness and our H-dot implementation of a sparse octal N-cube. 
     We proceed to the routing algorithm for a multidimensional octal n-cube. There are three pads to the routing algorithm. They are: initiate message transfer, accept a message, and keep a message. Remember, with sparseness, there was a cost. The cost is the additional transfers to get to the target PE after an address digit has been chosen to make a match. 
     Routing algorithm instructions are: 
     1. INITIATE--The PE will initiate a message using the port closest to the destination in a given unmatched digit. Referring to FIG. 12, PE(22) has a message for PE(34). PE will send the message out the port toward PE(23). Thus, PE(42) Right port would be used if Dest X is greater than Element X or if DX=EX and DY&gt;EY. (D for destination, E for this Element) 
     2. ACCEPT--A message would be accepted if the address matches the PE or if the PE can move the message closer to the destination. Thus, PE(42) Accepts From the Left if DX=&gt;EX and DY=&lt;EX 
     3. KEEP--Keep the message if it is for the PE, else pass it on out the other port. 
     Note that as with the mesh routing, there are four different sets of routing criteria depending on the PE&#34;s position on the H-dot. 
     FIG. 13 shows a block diagram of a parallel array processor we have described with a 2-D H-dot array, while FIG. 14 shows the picket PME we have described. As we have already described these FIGURES above, with additional details in related applications, we will need not repeat the descriptions, which are incorporated by reference. The system is a parallel array processor which provides SIMD/MIMD operational characteristics. The picket PMEs do not have to contain an entire operating system, but can function in MIMD mode independently, and also in a SIMD mode, with the capability of dynamic switching. Each picket has configuration we have described earlier and elsewhere. 
     While we have described our preferred embodiments of our invention, it will be understood that those skilled in the art, both now and in the future, may make various improvements and enhancements which fall within the scope of the claims which follow. These claims should be construed to maintain the proper protection for the invention first disclosed.